2 * Copyright (c) 2000-2012 Liferay, Inc. All rights reserved.
\r
4 * This library is free software; you can redistribute it and/or modify it under
\r
5 * the terms of the GNU Lesser General Public License as published by the Free
\r
6 * Software Foundation; either version 2.1 of the License, or (at your option)
\r
9 * This library is distributed in the hope that it will be useful, but WITHOUT
\r
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
\r
11 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
\r
15 package com.liferay.portal.service.impl;
\r
17 import com.liferay.portal.kernel.cluster.Clusterable;
\r
18 import com.liferay.portal.kernel.exception.PortalException;
\r
19 import com.liferay.portal.kernel.exception.SystemException;
\r
20 import com.liferay.portal.kernel.image.SpriteProcessorUtil;
\r
21 import com.liferay.portal.kernel.log.Log;
\r
22 import com.liferay.portal.kernel.log.LogFactoryUtil;
\r
23 import com.liferay.portal.kernel.plugin.PluginPackage;
\r
24 import com.liferay.portal.kernel.portlet.FriendlyURLMapper;
\r
25 import com.liferay.portal.kernel.portlet.LiferayPortletConfig;
\r
26 import com.liferay.portal.kernel.portlet.LiferayWindowState;
\r
27 import com.liferay.portal.kernel.scheduler.SchedulerEntry;
\r
28 import com.liferay.portal.kernel.scheduler.SchedulerEntryImpl;
\r
29 import com.liferay.portal.kernel.scheduler.TimeUnit;
\r
30 import com.liferay.portal.kernel.scheduler.TriggerType;
\r
31 import com.liferay.portal.kernel.servlet.ServletContextUtil;
\r
32 import com.liferay.portal.kernel.spring.aop.Skip;
\r
33 import com.liferay.portal.kernel.transaction.Transactional;
\r
34 import com.liferay.portal.kernel.util.CharPool;
\r
35 import com.liferay.portal.kernel.util.ContentTypes;
\r
36 import com.liferay.portal.kernel.util.GetterUtil;
\r
37 import com.liferay.portal.kernel.util.ListUtil;
\r
38 import com.liferay.portal.kernel.util.ServerDetector;
\r
39 import com.liferay.portal.kernel.util.StringPool;
\r
40 import com.liferay.portal.kernel.util.StringUtil;
\r
41 import com.liferay.portal.kernel.util.Validator;
\r
42 import com.liferay.portal.kernel.xml.Document;
\r
43 import com.liferay.portal.kernel.xml.Element;
\r
44 import com.liferay.portal.kernel.xml.QName;
\r
45 import com.liferay.portal.kernel.xml.SAXReaderUtil;
\r
46 import com.liferay.portal.model.CompanyConstants;
\r
47 import com.liferay.portal.model.EventDefinition;
\r
48 import com.liferay.portal.model.Portlet;
\r
49 import com.liferay.portal.model.PortletApp;
\r
50 import com.liferay.portal.model.PortletCategory;
\r
51 import com.liferay.portal.model.PortletConstants;
\r
52 import com.liferay.portal.model.PortletFilter;
\r
53 import com.liferay.portal.model.PortletInfo;
\r
54 import com.liferay.portal.model.PortletURLListener;
\r
55 import com.liferay.portal.model.PublicRenderParameter;
\r
56 import com.liferay.portal.model.ResourceConstants;
\r
57 import com.liferay.portal.model.Role;
\r
58 import com.liferay.portal.model.impl.EventDefinitionImpl;
\r
59 import com.liferay.portal.model.impl.PortletAppImpl;
\r
60 import com.liferay.portal.model.impl.PortletFilterImpl;
\r
61 import com.liferay.portal.model.impl.PortletImpl;
\r
62 import com.liferay.portal.model.impl.PortletURLListenerImpl;
\r
63 import com.liferay.portal.model.impl.PublicRenderParameterImpl;
\r
64 import com.liferay.portal.security.permission.ActionKeys;
\r
65 import com.liferay.portal.security.permission.ResourceActionsUtil;
\r
66 import com.liferay.portal.service.base.PortletLocalServiceBaseImpl;
\r
67 import com.liferay.portal.util.PortalUtil;
\r
68 import com.liferay.portal.util.PortletKeys;
\r
69 import com.liferay.portal.util.PropsValues;
\r
70 import com.liferay.portal.util.WebAppPool;
\r
71 import com.liferay.portal.util.WebKeys;
\r
72 import com.liferay.portlet.PortletConfigFactoryUtil;
\r
73 import com.liferay.portlet.PortletContextFactory;
\r
74 import com.liferay.portlet.PortletInstanceFactoryUtil;
\r
75 import com.liferay.portlet.PortletPreferencesFactoryUtil;
\r
76 import com.liferay.portlet.PortletQNameUtil;
\r
77 import com.liferay.portlet.expando.model.CustomAttributesDisplay;
\r
78 import com.liferay.util.ContentUtil;
\r
79 import com.liferay.util.bridges.mvc.MVCPortlet;
\r
81 import java.io.File;
\r
83 import java.util.ArrayList;
\r
84 import java.util.HashMap;
\r
85 import java.util.HashSet;
\r
86 import java.util.Iterator;
\r
87 import java.util.LinkedHashSet;
\r
88 import java.util.List;
\r
89 import java.util.Map;
\r
90 import java.util.Properties;
\r
91 import java.util.Set;
\r
92 import java.util.concurrent.ConcurrentHashMap;
\r
94 import javax.portlet.PortletMode;
\r
95 import javax.portlet.PreferencesValidator;
\r
96 import javax.portlet.WindowState;
\r
98 import javax.servlet.ServletContext;
\r
101 * @author Brian Wing Shun Chan
\r
102 * @author Raymond Augé
\r
103 * @author Eduardo Lundgren
\r
104 * @author Wesley Gong
\r
105 * @author Shuyang Zhou
\r
107 public class PortletLocalServiceImpl extends PortletLocalServiceBaseImpl {
\r
110 public void addPortletCategory(long companyId, String categoryName) {
\r
111 PortletCategory portletCategory = (PortletCategory)WebAppPool.get(
\r
112 companyId, WebKeys.PORTLET_CATEGORY);
\r
114 if (portletCategory == null) {
\r
116 "Unable to add portlet category for company " + companyId +
\r
117 " because it does not exist");
\r
122 PortletCategory newPortletCategory = new PortletCategory(categoryName);
\r
124 if (newPortletCategory.getParentCategory() == null) {
\r
125 PortletCategory rootPortletCategory = new PortletCategory();
\r
127 rootPortletCategory.addCategory(newPortletCategory);
\r
130 portletCategory.merge(newPortletCategory.getRootCategory());
\r
133 public void checkPortlet(Portlet portlet)
\r
134 throws PortalException, SystemException {
\r
136 if (portlet.isSystem()) {
\r
140 String[] roleNames = portlet.getRolesArray();
\r
142 if (roleNames.length == 0) {
\r
146 long companyId = portlet.getCompanyId();
\r
147 String name = portlet.getPortletId();
\r
148 int scope = ResourceConstants.SCOPE_COMPANY;
\r
149 String primKey = String.valueOf(companyId);
\r
150 String actionId = ActionKeys.ADD_TO_PAGE;
\r
152 List<String> actionIds = ResourceActionsUtil.getPortletResourceActions(
\r
155 if (actionIds.contains(actionId)) {
\r
156 for (String roleName : roleNames) {
\r
157 Role role = roleLocalService.getRole(companyId, roleName);
\r
159 if (PropsValues.PERMISSIONS_USER_CHECK_ALGORITHM == 6) {
\r
160 if (resourceBlockLocalService.isSupported(name)) {
\r
161 resourceBlockLocalService.addCompanyScopePermission(
\r
162 companyId, name, role.getRoleId(), actionId);
\r
165 resourcePermissionLocalService.addResourcePermission(
\r
166 companyId, name, scope, primKey, role.getRoleId(),
\r
171 permissionLocalService.setRolePermission(
\r
172 role.getRoleId(), companyId, name, scope, primKey,
\r
179 companyId, portlet.getPortletId(), StringPool.BLANK,
\r
180 portlet.isActive());
\r
183 public void checkPortlets(long companyId)
\r
184 throws PortalException, SystemException {
\r
186 List<Portlet> portlets = getPortlets(companyId);
\r
188 for (Portlet portlet : portlets) {
\r
189 checkPortlet(portlet);
\r
194 public void clearCache() {
\r
196 // Refresh security path to portlet id mapping for all portlets
\r
198 _portletIdsByStrutsPath.clear();
\r
200 // Refresh company portlets
\r
202 portletLocalService.clearCompanyPortletsPool();
\r
206 @Transactional(enabled = false)
\r
207 public void clearCompanyPortletsPool() {
\r
208 _companyPortletsPool.clear();
\r
212 * @deprecated {@link #clonePortlet(String)}
\r
215 public Portlet clonePortlet(long companyId, String portletId) {
\r
216 return clonePortlet(portletId);
\r
220 public Portlet clonePortlet(String portletId) {
\r
221 Portlet portlet = getPortletById(portletId);
\r
223 return (Portlet)portlet.clone();
\r
226 public Portlet deployRemotePortlet(Portlet portlet, String categoryName)
\r
227 throws PortalException, SystemException {
\r
229 return deployRemotePortlet(portlet, new String[] {categoryName});
\r
232 public Portlet deployRemotePortlet(Portlet portlet, String[] categoryNames)
\r
233 throws PortalException, SystemException {
\r
235 Map<String, Portlet> portletsPool = _getPortletsPool();
\r
237 portletsPool.put(portlet.getPortletId(), portlet);
\r
239 PortletInstanceFactoryUtil.clear(portlet, false);
\r
241 PortletConfigFactoryUtil.destroy(portlet);
\r
245 List<String> portletActions =
\r
246 ResourceActionsUtil.getPortletResourceActions(
\r
247 portlet.getPortletId());
\r
249 resourceActionLocalService.checkResourceActions(
\r
250 portlet.getPortletId(), portletActions);
\r
252 PortletCategory portletCategory = (PortletCategory)WebAppPool.get(
\r
253 portlet.getCompanyId(), WebKeys.PORTLET_CATEGORY);
\r
255 if (portletCategory == null) {
\r
257 "Unable to register remote portlet for company " +
\r
258 portlet.getCompanyId() + " because it does not exist");
\r
263 portletCategory.separate(portlet.getPortletId());
\r
265 for (String categoryName : categoryNames) {
\r
266 PortletCategory newPortletCategory = new PortletCategory(
\r
269 if (newPortletCategory.getParentCategory() == null) {
\r
270 PortletCategory rootPortletCategory = new PortletCategory();
\r
272 rootPortletCategory.addCategory(newPortletCategory);
\r
275 Set<String> portletIds = newPortletCategory.getPortletIds();
\r
277 portletIds.add(portlet.getPortletId());
\r
279 portletCategory.merge(newPortletCategory.getRootCategory());
\r
282 checkPortlet(portlet);
\r
288 public void destroyPortlet(Portlet portlet) {
\r
289 String portletId = portlet.getRootPortletId();
\r
291 _friendlyURLMapperPortlets.remove(portletId);
\r
293 Map<String, Portlet> portletsPool = _getPortletsPool();
\r
295 portletsPool.remove(portletId);
\r
297 PortletApp portletApp = portlet.getPortletApp();
\r
299 if (portletApp != null) {
\r
300 _portletAppsPool.remove(portletApp.getServletContextName());
\r
307 public void destroyRemotePortlet(Portlet portlet) {
\r
308 destroyPortlet(portlet);
\r
312 public List<CustomAttributesDisplay> getCustomAttributesDisplays() {
\r
313 List<CustomAttributesDisplay> customAttributesDisplays =
\r
314 new ArrayList<CustomAttributesDisplay>(
\r
315 _customAttributesDisplayPortlets.size());
\r
317 for (Map.Entry<String, Portlet> entry :
\r
318 _customAttributesDisplayPortlets.entrySet()) {
\r
320 Portlet portlet = entry.getValue();
\r
322 List<CustomAttributesDisplay> portletCustomAttributesDisplays =
\r
323 portlet.getCustomAttributesDisplayInstances();
\r
325 if ((portletCustomAttributesDisplays != null) &&
\r
326 !portletCustomAttributesDisplays.isEmpty()) {
\r
328 customAttributesDisplays.addAll(
\r
329 portletCustomAttributesDisplays);
\r
333 return customAttributesDisplays;
\r
337 public PortletCategory getEARDisplay(String xml) throws SystemException {
\r
339 return _readLiferayDisplayXML(xml);
\r
341 catch (Exception e) {
\r
342 throw new SystemException(e);
\r
347 public List<Portlet> getFriendlyURLMapperPortlets() {
\r
348 List<Portlet> portlets = new ArrayList<Portlet>(
\r
349 _friendlyURLMapperPortlets.size());
\r
351 for (Map.Entry<String, Portlet> entry :
\r
352 _friendlyURLMapperPortlets.entrySet()) {
\r
354 Portlet portlet = entry.getValue();
\r
356 FriendlyURLMapper friendlyURLMapper =
\r
357 portlet.getFriendlyURLMapperInstance();
\r
359 if (friendlyURLMapper != null) {
\r
360 portlets.add(portlet);
\r
368 public List<FriendlyURLMapper> getFriendlyURLMappers() {
\r
369 List<FriendlyURLMapper> friendlyURLMappers =
\r
370 new ArrayList<FriendlyURLMapper>(_friendlyURLMapperPortlets.size());
\r
372 for (Map.Entry<String, Portlet> entry :
\r
373 _friendlyURLMapperPortlets.entrySet()) {
\r
375 Portlet portlet = entry.getValue();
\r
377 FriendlyURLMapper friendlyURLMapper =
\r
378 portlet.getFriendlyURLMapperInstance();
\r
380 if (friendlyURLMapper != null) {
\r
381 friendlyURLMappers.add(friendlyURLMapper);
\r
385 return friendlyURLMappers;
\r
389 public PortletApp getPortletApp(String servletContextName) {
\r
390 return _getPortletApp(servletContextName);
\r
394 public Portlet getPortletById(long companyId, String portletId)
\r
395 throws SystemException {
\r
397 portletId = PortalUtil.getJsSafePortletId(portletId);
\r
399 Portlet portlet = null;
\r
401 Map<String, Portlet> companyPortletsPool = _getPortletsPool(companyId);
\r
403 String rootPortletId = PortletConstants.getRootPortletId(portletId);
\r
405 if (portletId.equals(rootPortletId)) {
\r
406 portlet = companyPortletsPool.get(portletId);
\r
409 portlet = companyPortletsPool.get(rootPortletId);
\r
411 if (portlet != null) {
\r
412 portlet = portlet.getClonedInstance(portletId);
\r
416 if (portlet != null) {
\r
420 if (portletId.equals(PortletKeys.LIFERAY_PORTAL)) {
\r
424 if (_portletsPool.isEmpty()) {
\r
425 if (_log.isDebugEnabled()) {
\r
426 _log.debug("No portlets are installed");
\r
430 if (_log.isInfoEnabled()) {
\r
432 "Portlet not found for " + companyId + " " + portletId);
\r
435 portlet = new PortletImpl(CompanyConstants.SYSTEM, portletId);
\r
437 portlet.setTimestamp(System.currentTimeMillis());
\r
439 PortletApp portletApp = _getPortletApp(StringPool.BLANK);
\r
441 portlet.setPortletApp(portletApp);
\r
443 portlet.setPortletName(portletId);
\r
444 portlet.setDisplayName(portletId);
\r
445 portlet.setPortletClass(MVCPortlet.class.getName());
\r
447 Map<String, String> initParams = portlet.getInitParams();
\r
449 initParams.put("view-jsp", "/html/portal/undeployed_portlet.jsp");
\r
451 Set<String> mimeTypePortletModes = new HashSet<String>();
\r
453 mimeTypePortletModes.add(PortletMode.VIEW.toString().toLowerCase());
\r
455 Map<String, Set<String>> portletModes = portlet.getPortletModes();
\r
457 portletModes.put(ContentTypes.TEXT_HTML, mimeTypePortletModes);
\r
459 Set<String> mimeTypeWindowStates = new HashSet<String>();
\r
461 mimeTypeWindowStates.add(
\r
462 WindowState.NORMAL.toString().toLowerCase());
\r
464 Map<String, Set<String>> windowStates = portlet.getWindowStates();
\r
466 windowStates.put(ContentTypes.TEXT_HTML, mimeTypeWindowStates);
\r
468 portlet.setPortletInfo(
\r
469 new PortletInfo(portletId, portletId, portletId, portletId));
\r
471 if (PortletConstants.hasInstanceId(portletId)) {
\r
472 portlet.setInstanceable(true);
\r
475 portlet.setActive(true);
\r
476 portlet.setUndeployedPortlet(true);
\r
483 public Portlet getPortletById(String portletId) {
\r
484 Map<String, Portlet> portletsPool = _getPortletsPool();
\r
486 return portletsPool.get(portletId);
\r
490 public Portlet getPortletByStrutsPath(long companyId, String strutsPath)
\r
491 throws SystemException {
\r
493 return getPortletById(companyId, _getPortletId(strutsPath));
\r
497 public List<Portlet> getPortlets() {
\r
498 Map<String, Portlet> portletsPool = _getPortletsPool();
\r
500 return ListUtil.fromMapValues(portletsPool);
\r
504 public List<Portlet> getPortlets(long companyId) throws SystemException {
\r
505 return getPortlets(companyId, true, true);
\r
509 public List<Portlet> getPortlets(
\r
510 long companyId, boolean showSystem, boolean showPortal)
\r
511 throws SystemException {
\r
513 Map<String, Portlet> portletsPool = _getPortletsPool(companyId);
\r
515 List<Portlet> portlets = ListUtil.fromMapValues(portletsPool);
\r
517 if (!showSystem || !showPortal) {
\r
518 Iterator<Portlet> itr = portlets.iterator();
\r
520 while (itr.hasNext()) {
\r
521 Portlet portlet = itr.next();
\r
524 portlet.getPortletId().equals(PortletKeys.PORTAL)) {
\r
527 else if (!showPortal &&
\r
528 portlet.getPortletId().equals(PortletKeys.PORTAL)) {
\r
532 else if (!showSystem && portlet.isSystem()) {
\r
542 public List<Portlet> getScopablePortlets() {
\r
543 Map<String, Portlet> portletsPool = _getPortletsPool();
\r
545 List<Portlet> portlets = ListUtil.fromMapValues(portletsPool);
\r
547 Iterator<Portlet> itr = portlets.iterator();
\r
549 while (itr.hasNext()) {
\r
550 Portlet portlet = itr.next();
\r
552 if (!portlet.isScopeable()) {
\r
561 public PortletCategory getWARDisplay(String servletContextName, String xml)
\r
562 throws SystemException {
\r
565 return _readLiferayDisplayXML(servletContextName, xml);
\r
567 catch (Exception e) {
\r
568 throw new SystemException(e);
\r
573 public boolean hasPortlet(long companyId, String portletId)
\r
574 throws SystemException {
\r
576 portletId = PortalUtil.getJsSafePortletId(portletId);
\r
578 Portlet portlet = null;
\r
580 Map<String, Portlet> companyPortletsPool = _getPortletsPool(companyId);
\r
582 String rootPortletId = PortletConstants.getRootPortletId(portletId);
\r
584 if (portletId.equals(rootPortletId)) {
\r
585 portlet = companyPortletsPool.get(portletId);
\r
588 portlet = companyPortletsPool.get(rootPortletId);
\r
591 if (portlet == null) {
\r
600 public void initEAR(
\r
601 ServletContext servletContext, String[] xmls,
\r
602 PluginPackage pluginPackage) {
\r
604 // Clear pools every time initEAR is called. See LEP-5452.
\r
606 portletLocalService.clearCompanyPortletsPool();
\r
608 _portletAppsPool.clear();
\r
609 _portletsPool.clear();
\r
610 _portletIdsByStrutsPath.clear();
\r
611 _friendlyURLMapperPortlets.clear();
\r
613 Map<String, Portlet> portletsPool = _getPortletsPool();
\r
616 Set<String> servletURLPatterns = _readWebXML(xmls[4]);
\r
618 Set<String> portletIds = _readPortletXML(
\r
619 servletContext, xmls[0], portletsPool, servletURLPatterns,
\r
624 servletContext, xmls[1], portletsPool, servletURLPatterns,
\r
627 Set<String> liferayPortletIds = _readLiferayPortletXML(
\r
628 xmls[2], portletsPool);
\r
630 liferayPortletIds.addAll(
\r
631 _readLiferayPortletXML(xmls[3], portletsPool));
\r
633 // Check for missing entries in liferay-portlet.xml
\r
635 for (String portletId : portletIds) {
\r
636 if (_log.isWarnEnabled() &&
\r
637 !liferayPortletIds.contains(portletId)) {
\r
640 "Portlet with the name " + portletId +
\r
641 " is described in portlet.xml but does not " +
\r
642 "have a matching entry in liferay-portlet.xml");
\r
646 // Check for missing entries in portlet.xml
\r
648 for (String portletId : liferayPortletIds) {
\r
649 if (_log.isWarnEnabled() && !portletIds.contains(portletId)) {
\r
651 "Portlet with the name " + portletId +
\r
652 " is described in liferay-portlet.xml but does " +
\r
653 "not have a matching entry in portlet.xml");
\r
657 // Remove portlets that should not be included
\r
659 Iterator<Map.Entry<String, Portlet>> portletPoolsItr =
\r
660 portletsPool.entrySet().iterator();
\r
662 while (portletPoolsItr.hasNext()) {
\r
663 Map.Entry<String, Portlet> entry = portletPoolsItr.next();
\r
665 Portlet portletModel = entry.getValue();
\r
667 if (!portletModel.getPortletId().equals(PortletKeys.ADMIN) &&
\r
668 !portletModel.getPortletId().equals(
\r
669 PortletKeys.MY_ACCOUNT) &&
\r
670 !portletModel.isInclude()) {
\r
672 portletPoolsItr.remove();
\r
674 _friendlyURLMapperPortlets.remove(
\r
675 portletModel.getPortletId());
\r
681 PortletApp portletApp = _getPortletApp(StringPool.BLANK);
\r
683 _setSpriteImages(servletContext, portletApp, "/html/icons/");
\r
685 catch (Exception e) {
\r
691 public List<Portlet> initWAR(
\r
692 String servletContextName, ServletContext servletContext, String[] xmls,
\r
693 PluginPackage pluginPackage) {
\r
695 List<Portlet> portlets = new ArrayList<Portlet>();
\r
697 Map<String, Portlet> portletsPool = _getPortletsPool();
\r
700 Set<String> servletURLPatterns = _readWebXML(xmls[3]);
\r
702 Set<String> portletIds = _readPortletXML(
\r
703 servletContextName, servletContext, xmls[0], portletsPool,
\r
704 servletURLPatterns, pluginPackage);
\r
708 servletContextName, servletContext, xmls[1], portletsPool,
\r
709 servletURLPatterns, pluginPackage));
\r
711 Set<String> liferayPortletIds = _readLiferayPortletXML(
\r
712 servletContextName, xmls[2], portletsPool);
\r
714 // Check for missing entries in liferay-portlet.xml
\r
716 for (String portletId : portletIds) {
\r
717 if (_log.isWarnEnabled() &&
\r
718 !liferayPortletIds.contains(portletId)) {
\r
721 "Portlet with the name " + portletId +
\r
722 " is described in portlet.xml but does not " +
\r
723 "have a matching entry in liferay-portlet.xml");
\r
727 // Check for missing entries in portlet.xml
\r
729 for (String portletId : liferayPortletIds) {
\r
730 if (_log.isWarnEnabled() && !portletIds.contains(portletId)) {
\r
732 "Portlet with the name " + portletId +
\r
733 " is described in liferay-portlet.xml but does " +
\r
734 "not have a matching entry in portlet.xml");
\r
738 // Return the new portlets
\r
740 for (String portletId : portletIds) {
\r
741 Portlet portlet = _getPortletsPool().get(portletId);
\r
743 portlets.add(portlet);
\r
745 PortletInstanceFactoryUtil.clear(portlet);
\r
747 PortletConfigFactoryUtil.destroy(portlet);
\r
748 PortletContextFactory.destroy(portlet);
\r
753 PortletApp portletApp = _getPortletApp(servletContextName);
\r
755 _setSpriteImages(servletContext, portletApp, "/icons/");
\r
757 catch (Exception e) {
\r
766 public Map<String, Portlet> loadGetPortletsPool(long companyId)
\r
767 throws SystemException {
\r
769 Map<String, Portlet> portletsPool =
\r
770 new ConcurrentHashMap<String, Portlet>();
\r
772 Map<String, Portlet> parentPortletsPool = _getPortletsPool();
\r
774 if (parentPortletsPool == null) {
\r
776 // The Upgrade scripts sometimes try to access portlet preferences
\r
777 // before the portal's been initialized. Return an empty pool.
\r
779 return portletsPool;
\r
782 for (Portlet portlet : parentPortletsPool.values()) {
\r
783 portlet = (Portlet)portlet.clone();
\r
785 portlet.setCompanyId(companyId);
\r
787 portletsPool.put(portlet.getPortletId(), portlet);
\r
790 List<Portlet> portlets = portletPersistence.findByCompanyId(companyId);
\r
792 for (Portlet portlet : portlets) {
\r
793 Portlet portletModel = portletsPool.get(portlet.getPortletId());
\r
795 // Portlet may be null if it exists in the database but its portlet
\r
796 // WAR is not yet loaded
\r
798 if (portletModel != null) {
\r
799 portletModel.setPluginPackage(portlet.getPluginPackage());
\r
800 portletModel.setDefaultPluginSetting(
\r
801 portlet.getDefaultPluginSetting());
\r
802 portletModel.setRoles(portlet.getRoles());
\r
803 portletModel.setActive(portlet.getActive());
\r
807 return portletsPool;
\r
811 @Transactional(enabled = false)
\r
812 public void removeCompanyPortletsPool(long companyId) {
\r
813 _companyPortletsPool.remove(companyId);
\r
816 public Portlet updatePortlet(
\r
817 long companyId, String portletId, String roles, boolean active)
\r
818 throws SystemException {
\r
820 portletId = PortalUtil.getJsSafePortletId(portletId);
\r
822 Portlet portlet = portletPersistence.fetchByC_P(companyId, portletId);
\r
824 if (portlet == null) {
\r
825 long id = counterLocalService.increment();
\r
827 portlet = portletPersistence.create(id);
\r
829 portlet.setCompanyId(companyId);
\r
830 portlet.setPortletId(portletId);
\r
833 portlet.setRoles(roles);
\r
834 portlet.setActive(active);
\r
836 portletPersistence.update(portlet, false);
\r
838 portlet = getPortletById(companyId, portletId);
\r
840 portlet.setRoles(roles);
\r
841 portlet.setActive(active);
\r
843 portletLocalService.removeCompanyPortletsPool(companyId);
\r
848 private PortletApp _getPortletApp(String servletContextName) {
\r
849 PortletApp portletApp = _portletAppsPool.get(servletContextName);
\r
851 if (portletApp == null) {
\r
852 portletApp = new PortletAppImpl(servletContextName);
\r
854 _portletAppsPool.put(servletContextName, portletApp);
\r
860 private String _getPortletId(String securityPath) {
\r
861 if (_portletIdsByStrutsPath.isEmpty()) {
\r
862 for (Portlet portlet : _getPortletsPool().values()) {
\r
863 String strutsPath = portlet.getStrutsPath();
\r
865 if (_portletIdsByStrutsPath.containsKey(strutsPath)) {
\r
866 //_log.warn("Duplicate struts path " + strutsPath);
\r
869 _portletIdsByStrutsPath.put(strutsPath, portlet.getPortletId());
\r
873 String portletId = _portletIdsByStrutsPath.get(securityPath);
\r
875 if (Validator.isNull(portletId)) {
\r
876 for (String strutsPath : _portletIdsByStrutsPath.keySet()) {
\r
877 if (securityPath.startsWith(
\r
878 strutsPath.concat(StringPool.SLASH))) {
\r
880 portletId = _portletIdsByStrutsPath.get(strutsPath);
\r
887 if (Validator.isNull(portletId)) {
\r
889 "Struts path " + securityPath + " is not mapped to a portlet " +
\r
890 "in liferay-portlet.xml");
\r
896 private List<Portlet> _getPortletsByPortletName(
\r
897 String portletName, String servletContextName,
\r
898 Map<String, Portlet> portletsPool) {
\r
900 List<Portlet> portlets = null;
\r
902 int pos = portletName.indexOf(CharPool.STAR);
\r
905 portlets = new ArrayList<Portlet>();
\r
907 String portletId = portletName;
\r
909 if (Validator.isNotNull(servletContextName)) {
\r
911 portletId + PortletConstants.WAR_SEPARATOR +
\r
912 servletContextName;
\r
915 portletId = PortalUtil.getJsSafePortletId(portletId);
\r
917 Portlet portlet = portletsPool.get(portletId);
\r
919 if (portlet != null) {
\r
920 portlets.add(portlet);
\r
926 String portletNamePrefix = portletName.substring(0, pos);
\r
928 portlets = _getPortletsByServletContextName(
\r
929 servletContextName, portletsPool);
\r
931 Iterator<Portlet> itr = portlets.iterator();
\r
933 while (itr.hasNext()) {
\r
934 Portlet portlet = itr.next();
\r
936 String portletId = portlet.getPortletId();
\r
938 if (!portletId.startsWith(portletNamePrefix)) {
\r
946 private List<Portlet> _getPortletsByServletContextName(
\r
947 String servletContextName, Map<String, Portlet> portletsPool) {
\r
949 List<Portlet> portlets = new ArrayList<Portlet>();
\r
951 String servletContextNameSuffix = servletContextName;
\r
953 if (Validator.isNotNull(servletContextName)) {
\r
954 servletContextNameSuffix = PortalUtil.getJsSafePortletId(
\r
955 PortletConstants.WAR_SEPARATOR.concat(servletContextName));
\r
958 for (Map.Entry<String, Portlet> entry : portletsPool.entrySet()) {
\r
959 String portletId = entry.getKey();
\r
960 Portlet portlet = entry.getValue();
\r
962 if (Validator.isNotNull(servletContextNameSuffix)) {
\r
963 if (portletId.endsWith(servletContextNameSuffix)) {
\r
965 portlets.add(portlet);
\r
969 if (!portletId.contains(PortletConstants.WAR_SEPARATOR)) {
\r
970 portlets.add(portlet);
\r
978 private Map<String, Portlet> _getPortletsPool() {
\r
979 return _portletsPool;
\r
982 private Map<String, Portlet> _getPortletsPool(long companyId)
\r
983 throws SystemException {
\r
985 Map<String, Portlet> portletsPool = _companyPortletsPool.get(companyId);
\r
987 if (portletsPool == null) {
\r
988 portletsPool = portletLocalService.loadGetPortletsPool(companyId);
\r
990 _companyPortletsPool.put(companyId, portletsPool);
\r
993 return portletsPool;
\r
996 private void _readLiferayDisplay(
\r
997 String servletContextName, Element element,
\r
998 PortletCategory portletCategory, Set<String> portletIds) {
\r
1000 for (Element categoryElement : element.elements("category")) {
\r
1001 String name = categoryElement.attributeValue("name");
\r
1003 PortletCategory curPortletCategory = new PortletCategory(name);
\r
1005 portletCategory.addCategory(curPortletCategory);
\r
1007 Set<String> curPortletIds = curPortletCategory.getPortletIds();
\r
1009 for (Element portletElement : categoryElement.elements("portlet")) {
\r
1010 String portletId = portletElement.attributeValue("id");
\r
1012 if (Validator.isNotNull(servletContextName)) {
\r
1014 portletId + PortletConstants.WAR_SEPARATOR +
\r
1015 servletContextName;
\r
1018 portletId = PortalUtil.getJsSafePortletId(portletId);
\r
1020 portletIds.add(portletId);
\r
1021 curPortletIds.add(portletId);
\r
1024 _readLiferayDisplay(
\r
1025 servletContextName, categoryElement, curPortletCategory,
\r
1030 private PortletCategory _readLiferayDisplayXML(String xml)
\r
1031 throws Exception {
\r
1033 return _readLiferayDisplayXML(null, xml);
\r
1036 private PortletCategory _readLiferayDisplayXML(
\r
1037 String servletContextName, String xml)
\r
1038 throws Exception {
\r
1040 PortletCategory portletCategory = new PortletCategory();
\r
1042 if (xml == null) {
\r
1043 xml = ContentUtil.get(
\r
1044 "com/liferay/portal/deploy/dependencies/liferay-display.xml");
\r
1047 Document document = SAXReaderUtil.read(xml, true);
\r
1049 Element rootElement = document.getRootElement();
\r
1051 Set<String> portletIds = new HashSet<String>();
\r
1053 _readLiferayDisplay(
\r
1054 servletContextName, rootElement, portletCategory, portletIds);
\r
1056 // Portlets that do not belong to any categories should default to the
\r
1057 // Undefined category
\r
1059 Set<String> undefinedPortletIds = new HashSet<String>();
\r
1061 for (Portlet portlet : _getPortletsPool().values()) {
\r
1062 String portletId = portlet.getPortletId();
\r
1064 PortletApp portletApp = portlet.getPortletApp();
\r
1066 if ((servletContextName != null) && portletApp.isWARFile() &&
\r
1067 (portletId.endsWith(
\r
1068 PortletConstants.WAR_SEPARATOR +
\r
1069 PortalUtil.getJsSafePortletId(servletContextName)) &&
\r
1070 !portletIds.contains(portletId))) {
\r
1072 undefinedPortletIds.add(portletId);
\r
1074 else if ((servletContextName == null) &&
\r
1075 !portletApp.isWARFile() &&
\r
1076 (portletId.indexOf(
\r
1077 PortletConstants.WAR_SEPARATOR) == -1) &&
\r
1078 !portletIds.contains(portletId)) {
\r
1080 undefinedPortletIds.add(portletId);
\r
1084 if (!undefinedPortletIds.isEmpty()) {
\r
1085 PortletCategory undefinedCategory = new PortletCategory(
\r
1086 "category.undefined");
\r
1088 portletCategory.addCategory(undefinedCategory);
\r
1090 undefinedCategory.getPortletIds().addAll(undefinedPortletIds);
\r
1093 return portletCategory;
\r
1096 private Set<String> _readLiferayPortletXML(
\r
1097 String xml, Map<String, Portlet> portletsPool)
\r
1098 throws Exception {
\r
1100 return _readLiferayPortletXML(StringPool.BLANK, xml, portletsPool);
\r
1103 private void _readLiferayPortletXML(
\r
1104 String servletContextName, Map<String, Portlet> portletsPool,
\r
1105 Set<String> liferayPortletIds, Map<String, String> roleMappers,
\r
1106 Element portletElement) {
\r
1108 String portletId = portletElement.elementText("portlet-name");
\r
1110 if (Validator.isNotNull(servletContextName)) {
\r
1111 portletId = portletId.concat(PortletConstants.WAR_SEPARATOR).concat(
\r
1112 servletContextName);
\r
1115 portletId = PortalUtil.getJsSafePortletId(portletId);
\r
1117 if (_log.isDebugEnabled()) {
\r
1118 _log.debug("Reading portlet extension " + portletId);
\r
1121 liferayPortletIds.add(portletId);
\r
1123 Portlet portletModel = portletsPool.get(portletId);
\r
1125 if (portletModel == null) {
\r
1129 portletModel.setIcon(
\r
1130 GetterUtil.getString(
\r
1131 portletElement.elementText("icon"), portletModel.getIcon()));
\r
1132 portletModel.setVirtualPath(
\r
1133 GetterUtil.getString(
\r
1134 portletElement.elementText("virtual-path"),
\r
1135 portletModel.getVirtualPath()));
\r
1136 portletModel.setStrutsPath(
\r
1137 GetterUtil.getString(
\r
1138 portletElement.elementText("struts-path"),
\r
1139 portletModel.getStrutsPath()));
\r
1141 String strutsPath = portletModel.getStrutsPath();
\r
1143 if (Validator.isNotNull(strutsPath)) {
\r
1144 if (_portletIdsByStrutsPath.containsKey(strutsPath)) {
\r
1145 _log.warn("Duplicate struts path " + strutsPath);
\r
1148 _portletIdsByStrutsPath.put(strutsPath, portletId);
\r
1151 portletModel.setParentStrutsPath(
\r
1152 GetterUtil.getString(
\r
1153 portletElement.elementText("parent-struts-path"),
\r
1154 portletModel.getParentStrutsPath()));
\r
1156 if (Validator.isNotNull(
\r
1157 portletElement.elementText("configuration-path"))) {
\r
1160 "The configuration-path element is no longer supported. Use " +
\r
1161 "configuration-action-class instead.");
\r
1164 portletModel.setConfigurationActionClass(
\r
1165 GetterUtil.getString(
\r
1166 portletElement.elementText("configuration-action-class"),
\r
1167 portletModel.getConfigurationActionClass()));
\r
1169 List<String> indexerClasses = portletModel.getIndexerClasses();
\r
1171 for (Element indexerClassElement :
\r
1172 portletElement.elements("indexer-class")) {
\r
1174 indexerClasses.add(indexerClassElement.getText());
\r
1177 portletModel.setOpenSearchClass(
\r
1178 GetterUtil.getString(
\r
1179 portletElement.elementText("open-search-class"),
\r
1180 portletModel.getOpenSearchClass()));
\r
1182 for (Element schedulerEntryElement :
\r
1183 portletElement.elements("scheduler-entry")) {
\r
1185 SchedulerEntry schedulerEntry = new SchedulerEntryImpl();
\r
1187 schedulerEntry.setContextPath(portletModel.getContextPath());
\r
1188 schedulerEntry.setDescription(
\r
1189 GetterUtil.getString(
\r
1190 schedulerEntryElement.elementText(
\r
1191 "scheduler-description")));
\r
1192 schedulerEntry.setEventListenerClass(
\r
1193 GetterUtil.getString(
\r
1194 schedulerEntryElement.elementText(
\r
1195 "scheduler-event-listener-class"),
\r
1196 schedulerEntry.getEventListenerClass()));
\r
1198 Element triggerElement = schedulerEntryElement.element("trigger");
\r
1200 Element cronElement = triggerElement.element("cron");
\r
1201 Element simpleElement = triggerElement.element("simple");
\r
1203 if (cronElement != null) {
\r
1204 schedulerEntry.setTriggerType(TriggerType.CRON);
\r
1206 Element propertyKeyElement = cronElement.element(
\r
1209 if (propertyKeyElement != null) {
\r
1210 schedulerEntry.setPropertyKey(
\r
1211 propertyKeyElement.getTextTrim());
\r
1214 schedulerEntry.setTriggerValue(
\r
1215 cronElement.elementText("cron-trigger-value"));
\r
1218 else if (simpleElement != null) {
\r
1219 schedulerEntry.setTriggerType(TriggerType.SIMPLE);
\r
1221 Element propertyKeyElement = simpleElement.element(
\r
1224 if (propertyKeyElement != null) {
\r
1225 schedulerEntry.setPropertyKey(
\r
1226 propertyKeyElement.getTextTrim());
\r
1229 Element simpleTriggerValueElement = simpleElement.element(
\r
1230 "simple-trigger-value");
\r
1232 schedulerEntry.setTriggerValue(
\r
1233 simpleTriggerValueElement.getTextTrim());
\r
1236 String timeUnit = GetterUtil.getString(
\r
1237 simpleElement.elementText("time-unit"),
\r
1238 TimeUnit.SECOND.getValue());
\r
1240 schedulerEntry.setTimeUnit(
\r
1241 TimeUnit.parse(timeUnit.toLowerCase()));
\r
1244 portletModel.addSchedulerEntry(schedulerEntry);
\r
1247 portletModel.setPortletURLClass(
\r
1248 GetterUtil.getString(
\r
1249 portletElement.elementText("portlet-url-class"),
\r
1250 portletModel.getPortletURLClass()));
\r
1252 portletModel.setFriendlyURLMapperClass(
\r
1253 GetterUtil.getString(
\r
1254 portletElement.elementText("friendly-url-mapper-class"),
\r
1255 portletModel.getFriendlyURLMapperClass()));
\r
1257 if (Validator.isNull(portletModel.getFriendlyURLMapperClass())) {
\r
1258 _friendlyURLMapperPortlets.remove(portletId);
\r
1261 _friendlyURLMapperPortlets.put(portletId, portletModel);
\r
1264 portletModel.setFriendlyURLMapping(
\r
1265 GetterUtil.getString(
\r
1266 portletElement.elementText("friendly-url-mapping"),
\r
1267 portletModel.getFriendlyURLMapping()));
\r
1268 portletModel.setFriendlyURLRoutes(
\r
1269 GetterUtil.getString(
\r
1270 portletElement.elementText("friendly-url-routes"),
\r
1271 portletModel.getFriendlyURLRoutes()));
\r
1272 portletModel.setURLEncoderClass(
\r
1273 GetterUtil.getString(
\r
1274 portletElement.elementText("url-encoder-class"),
\r
1275 portletModel.getURLEncoderClass()));
\r
1276 portletModel.setPortletDataHandlerClass(
\r
1277 GetterUtil.getString(
\r
1278 portletElement.elementText("portlet-data-handler-class"),
\r
1279 portletModel.getPortletDataHandlerClass()));
\r
1280 portletModel.setPortletLayoutListenerClass(
\r
1281 GetterUtil.getString(
\r
1282 portletElement.elementText("portlet-layout-listener-class"),
\r
1283 portletModel.getPortletLayoutListenerClass()));
\r
1284 portletModel.setPollerProcessorClass(
\r
1285 GetterUtil.getString(
\r
1286 portletElement.elementText("poller-processor-class"),
\r
1287 portletModel.getPollerProcessorClass()));
\r
1288 portletModel.setPopMessageListenerClass(
\r
1289 GetterUtil.getString(
\r
1290 portletElement.elementText("pop-message-listener-class"),
\r
1291 portletModel.getPopMessageListenerClass()));
\r
1292 portletModel.setSocialActivityInterpreterClass(
\r
1293 GetterUtil.getString(
\r
1294 portletElement.elementText("social-activity-interpreter-class"),
\r
1295 portletModel.getSocialActivityInterpreterClass()));
\r
1296 portletModel.setSocialRequestInterpreterClass(
\r
1297 GetterUtil.getString(
\r
1298 portletElement.elementText("social-request-interpreter-class"),
\r
1299 portletModel.getSocialRequestInterpreterClass()));
\r
1300 portletModel.setWebDAVStorageToken(
\r
1301 GetterUtil.getString(
\r
1302 portletElement.elementText("webdav-storage-token"),
\r
1303 portletModel.getWebDAVStorageToken()));
\r
1304 portletModel.setWebDAVStorageClass(
\r
1305 GetterUtil.getString(
\r
1306 portletElement.elementText("webdav-storage-class"),
\r
1307 portletModel.getWebDAVStorageClass()));
\r
1308 portletModel.setXmlRpcMethodClass(
\r
1309 GetterUtil.getString(
\r
1310 portletElement.elementText("xml-rpc-method-class"),
\r
1311 portletModel.getXmlRpcMethodClass()));
\r
1312 portletModel.setControlPanelEntryCategory(
\r
1313 GetterUtil.getString(
\r
1314 portletElement.elementText("control-panel-entry-category"),
\r
1315 portletModel.getControlPanelEntryCategory()));
\r
1316 portletModel.setControlPanelEntryWeight(
\r
1317 GetterUtil.getDouble(
\r
1318 portletElement.elementText("control-panel-entry-weight"),
\r
1319 portletModel.getControlPanelEntryWeight()));
\r
1320 portletModel.setControlPanelEntryClass(
\r
1321 GetterUtil.getString(
\r
1322 portletElement.elementText("control-panel-entry-class"),
\r
1323 portletModel.getControlPanelEntryClass()));
\r
1325 List<String> assetRendererFactoryClasses =
\r
1326 portletModel.getAssetRendererFactoryClasses();
\r
1328 for (Element assetRendererFactoryClassElement :
\r
1329 portletElement.elements("asset-renderer-factory")) {
\r
1331 assetRendererFactoryClasses.add(
\r
1332 assetRendererFactoryClassElement.getText());
\r
1335 List<String> atomCollectionAdapterClasses =
\r
1336 portletModel.getAtomCollectionAdapterClasses();
\r
1338 for (Element atomCollectionAdapterClassElement :
\r
1339 portletElement.elements("atom-collection-adapter")) {
\r
1341 atomCollectionAdapterClasses.add(
\r
1342 atomCollectionAdapterClassElement.getText());
\r
1345 List<String> customAttributesDisplayClasses =
\r
1346 portletModel.getCustomAttributesDisplayClasses();
\r
1348 for (Element customAttributesDisplayClassElement :
\r
1349 portletElement.elements("custom-attributes-display")) {
\r
1351 customAttributesDisplayClasses.add(
\r
1352 customAttributesDisplayClassElement.getText());
\r
1355 if (customAttributesDisplayClasses.isEmpty()) {
\r
1356 _customAttributesDisplayPortlets.remove(portletId);
\r
1359 _customAttributesDisplayPortlets.put(portletId, portletModel);
\r
1362 portletModel.setPermissionPropagatorClass(
\r
1363 GetterUtil.getString(
\r
1364 portletElement.elementText("permission-propagator"),
\r
1365 portletModel.getPermissionPropagatorClass()));
\r
1367 List<String> workflowHandlerClasses =
\r
1368 portletModel.getWorkflowHandlerClasses();
\r
1370 for (Element workflowHandlerClassElement :
\r
1371 portletElement.elements("workflow-handler")) {
\r
1373 workflowHandlerClasses.add(workflowHandlerClassElement.getText());
\r
1376 portletModel.setPreferencesCompanyWide(
\r
1377 GetterUtil.getBoolean(
\r
1378 portletElement.elementText("preferences-company-wide"),
\r
1379 portletModel.isPreferencesCompanyWide()));
\r
1380 portletModel.setPreferencesUniquePerLayout(
\r
1381 GetterUtil.getBoolean(
\r
1382 portletElement.elementText("preferences-unique-per-layout"),
\r
1383 portletModel.isPreferencesUniquePerLayout()));
\r
1384 portletModel.setPreferencesOwnedByGroup(
\r
1385 GetterUtil.getBoolean(
\r
1386 portletElement.elementText("preferences-owned-by-group"),
\r
1387 portletModel.isPreferencesOwnedByGroup()));
\r
1388 portletModel.setUseDefaultTemplate(
\r
1389 GetterUtil.getBoolean(
\r
1390 portletElement.elementText("use-default-template"),
\r
1391 portletModel.isUseDefaultTemplate()));
\r
1392 portletModel.setShowPortletAccessDenied(
\r
1393 GetterUtil.getBoolean(
\r
1394 portletElement.elementText("show-portlet-access-denied"),
\r
1395 portletModel.isShowPortletAccessDenied()));
\r
1396 portletModel.setShowPortletInactive(
\r
1397 GetterUtil.getBoolean(
\r
1398 portletElement.elementText("show-portlet-inactive"),
\r
1399 portletModel.isShowPortletInactive()));
\r
1400 portletModel.setActionURLRedirect(
\r
1401 GetterUtil.getBoolean(
\r
1402 portletElement.elementText("action-url-redirect"),
\r
1403 portletModel.isActionURLRedirect()));
\r
1404 portletModel.setRestoreCurrentView(
\r
1405 GetterUtil.getBoolean(
\r
1406 portletElement.elementText("restore-current-view"),
\r
1407 portletModel.isRestoreCurrentView()));
\r
1408 portletModel.setMaximizeEdit(
\r
1409 GetterUtil.getBoolean(
\r
1410 portletElement.elementText("maximize-edit"),
\r
1411 portletModel.isMaximizeEdit()));
\r
1412 portletModel.setMaximizeHelp(
\r
1413 GetterUtil.getBoolean(
\r
1414 portletElement.elementText("maximize-help"),
\r
1415 portletModel.isMaximizeHelp()));
\r
1416 portletModel.setPopUpPrint(
\r
1417 GetterUtil.getBoolean(
\r
1418 portletElement.elementText("pop-up-print"),
\r
1419 portletModel.isPopUpPrint()));
\r
1420 portletModel.setLayoutCacheable(
\r
1421 GetterUtil.getBoolean(
\r
1422 portletElement.elementText("layout-cacheable"),
\r
1423 portletModel.isLayoutCacheable()));
\r
1424 portletModel.setInstanceable(
\r
1425 GetterUtil.getBoolean(
\r
1426 portletElement.elementText("instanceable"),
\r
1427 portletModel.isInstanceable()));
\r
1428 portletModel.setRemoteable(
\r
1429 GetterUtil.getBoolean(
\r
1430 portletElement.elementText("remoteable"),
\r
1431 portletModel.isRemoteable()));
\r
1432 portletModel.setScopeable(
\r
1433 GetterUtil.getBoolean(
\r
1434 portletElement.elementText("scopeable"),
\r
1435 portletModel.isScopeable()));
\r
1436 portletModel.setUserPrincipalStrategy(
\r
1437 GetterUtil.getString(
\r
1438 portletElement.elementText("user-principal-strategy"),
\r
1439 portletModel.getUserPrincipalStrategy()));
\r
1440 portletModel.setPrivateRequestAttributes(
\r
1441 GetterUtil.getBoolean(
\r
1442 portletElement.elementText("private-request-attributes"),
\r
1443 portletModel.isPrivateRequestAttributes()));
\r
1444 portletModel.setPrivateSessionAttributes(
\r
1445 GetterUtil.getBoolean(
\r
1446 portletElement.elementText("private-session-attributes"),
\r
1447 portletModel.isPrivateSessionAttributes()));
\r
1449 Element autopropagatedParametersElement = portletElement.element(
\r
1450 "autopropagated-parameters");
\r
1452 if (autopropagatedParametersElement != null) {
\r
1453 Set<String> autopropagatedParameters =
\r
1454 portletModel.getAutopropagatedParameters();
\r
1456 String[] autopropagatedParametersArray = StringUtil.split(
\r
1457 autopropagatedParametersElement.getText());
\r
1459 for (String autopropagatedParameter :
\r
1460 autopropagatedParametersArray) {
\r
1462 autopropagatedParameters.add(autopropagatedParameter);
\r
1466 portletModel.setActionTimeout(
\r
1467 GetterUtil.getInteger(
\r
1468 portletElement.elementText("action-timeout"),
\r
1469 portletModel.getActionTimeout()));
\r
1470 portletModel.setRenderTimeout(
\r
1471 GetterUtil.getInteger(
\r
1472 portletElement.elementText("render-timeout"),
\r
1473 portletModel.getRenderTimeout()));
\r
1474 portletModel.setRenderWeight(
\r
1475 GetterUtil.getInteger(
\r
1476 portletElement.elementText("render-weight"),
\r
1477 portletModel.getRenderWeight()));
\r
1478 portletModel.setAjaxable(
\r
1479 GetterUtil.getBoolean(
\r
1480 portletElement.elementText("ajaxable"),
\r
1481 portletModel.isAjaxable()));
\r
1483 List<String> headerPortalCssList = portletModel.getHeaderPortalCss();
\r
1485 for (Element headerPortalCssElement :
\r
1486 portletElement.elements("header-portal-css")) {
\r
1488 headerPortalCssList.add(headerPortalCssElement.getText());
\r
1491 List<String> headerPortletCssList = portletModel.getHeaderPortletCss();
\r
1493 for (Element headerPortletCssElement :
\r
1494 portletElement.elements("header-portlet-css")) {
\r
1496 headerPortletCssList.add(headerPortletCssElement.getText());
\r
1499 List<String> headerPortalJavaScriptList =
\r
1500 portletModel.getHeaderPortalJavaScript();
\r
1502 for (Element headerPortalJavaScriptElement :
\r
1503 portletElement.elements("header-portal-javascript")) {
\r
1505 headerPortalJavaScriptList.add(
\r
1506 headerPortalJavaScriptElement.getText());
\r
1509 List<String> headerPortletJavaScriptList =
\r
1510 portletModel.getHeaderPortletJavaScript();
\r
1512 for (Element headerPortletJavaScriptElement :
\r
1513 portletElement.elements("header-portlet-javascript")) {
\r
1515 headerPortletJavaScriptList.add(
\r
1516 headerPortletJavaScriptElement.getText());
\r
1519 List<String> footerPortalCssList = portletModel.getFooterPortalCss();
\r
1521 for (Element footerPortalCssElement :
\r
1522 portletElement.elements("footer-portal-css")) {
\r
1524 footerPortalCssList.add(footerPortalCssElement.getText());
\r
1527 List<String> footerPortletCssList = portletModel.getFooterPortletCss();
\r
1529 for (Element footerPortletCssElement :
\r
1530 portletElement.elements("footer-portlet-css")) {
\r
1532 footerPortletCssList.add(footerPortletCssElement.getText());
\r
1535 List<String> footerPortalJavaScriptList =
\r
1536 portletModel.getFooterPortalJavaScript();
\r
1538 for (Element footerPortalJavaScriptElement :
\r
1539 portletElement.elements("footer-portal-javascript")) {
\r
1541 footerPortalJavaScriptList.add(
\r
1542 footerPortalJavaScriptElement.getText());
\r
1545 List<String> footerPortletJavaScriptList =
\r
1546 portletModel.getFooterPortletJavaScript();
\r
1548 for (Element footerPortletJavaScriptElement :
\r
1549 portletElement.elements("footer-portlet-javascript")) {
\r
1551 footerPortletJavaScriptList.add(
\r
1552 footerPortletJavaScriptElement.getText());
\r
1555 portletModel.setCssClassWrapper(
\r
1556 GetterUtil.getString(
\r
1557 portletElement.elementText("css-class-wrapper"),
\r
1558 portletModel.getCssClassWrapper()));
\r
1559 portletModel.setFacebookIntegration(
\r
1560 GetterUtil.getString(
\r
1561 portletElement.elementText("facebook-integration"),
\r
1562 portletModel.getFacebookIntegration()));
\r
1563 portletModel.setAddDefaultResource(
\r
1564 GetterUtil.getBoolean(
\r
1565 portletElement.elementText("add-default-resource"),
\r
1566 portletModel.isAddDefaultResource()));
\r
1567 portletModel.setSystem(
\r
1568 GetterUtil.getBoolean(
\r
1569 portletElement.elementText("system"), portletModel.isSystem()));
\r
1570 portletModel.setActive(
\r
1571 GetterUtil.getBoolean(
\r
1572 portletElement.elementText("active"), portletModel.isActive()));
\r
1573 portletModel.setInclude(
\r
1574 GetterUtil.getBoolean(portletElement.elementText("include"),
\r
1575 portletModel.isInclude()));
\r
1577 if (Validator.isNull(servletContextName)) {
\r
1578 portletModel.setReady(true);
\r
1581 if (!portletModel.isAjaxable() &&
\r
1582 (portletModel.getRenderWeight() < 1)) {
\r
1584 portletModel.setRenderWeight(1);
\r
1587 portletModel.getRoleMappers().putAll(roleMappers);
\r
1588 portletModel.linkRoles();
\r
1591 private Set<String> _readLiferayPortletXML(
\r
1592 String servletContextName, String xml,
\r
1593 Map<String, Portlet> portletsPool)
\r
1594 throws Exception {
\r
1596 Set<String> liferayPortletIds = new HashSet<String>();
\r
1598 if (xml == null) {
\r
1599 return liferayPortletIds;
\r
1602 Document document = SAXReaderUtil.read(xml, true);
\r
1604 Element rootElement = document.getRootElement();
\r
1606 PortletApp portletApp = _getPortletApp(servletContextName);
\r
1608 Map<String, String> roleMappers = new HashMap<String, String>();
\r
1610 for (Element roleMapperElement : rootElement.elements("role-mapper")) {
\r
1611 String roleName = roleMapperElement.elementText("role-name");
\r
1612 String roleLink = roleMapperElement.elementText("role-link");
\r
1614 roleMappers.put(roleName, roleLink);
\r
1617 Map<String, String> customUserAttributes =
\r
1618 portletApp.getCustomUserAttributes();
\r
1620 for (Element customUserAttributeElement :
\r
1621 rootElement.elements("custom-user-attribute")) {
\r
1623 String customClass = customUserAttributeElement.elementText(
\r
1626 for (Element nameElement :
\r
1627 customUserAttributeElement.elements("name")) {
\r
1629 String name = nameElement.getText();
\r
1631 customUserAttributes.put(name, customClass);
\r
1635 for (Element portletElement : rootElement.elements("portlet")) {
\r
1636 _readLiferayPortletXML(
\r
1637 servletContextName, portletsPool, liferayPortletIds,
\r
1638 roleMappers, portletElement);
\r
1641 return liferayPortletIds;
\r
1644 private Set<String> _readPortletXML(
\r
1645 ServletContext servletContext, String xml,
\r
1646 Map<String, Portlet> portletsPool, Set<String> servletURLPatterns,
\r
1647 PluginPackage pluginPackage)
\r
1648 throws Exception {
\r
1650 return _readPortletXML(
\r
1651 StringPool.BLANK, servletContext, xml, portletsPool,
\r
1652 servletURLPatterns, pluginPackage);
\r
1655 private void _readPortletXML(
\r
1656 String servletContextName, Map<String, Portlet> portletsPool,
\r
1657 PluginPackage pluginPackage, PortletApp portletApp,
\r
1658 Set<String> portletIds, long timestamp, Element portletElement) {
\r
1660 String portletName = portletElement.elementText("portlet-name");
\r
1662 String portletId = portletName;
\r
1664 if (Validator.isNotNull(servletContextName)) {
\r
1665 portletId = portletId.concat(PortletConstants.WAR_SEPARATOR).concat(
\r
1666 servletContextName);
\r
1669 portletId = PortalUtil.getJsSafePortletId(portletId);
\r
1671 if (_log.isDebugEnabled()) {
\r
1672 _log.debug("Reading portlet " + portletId);
\r
1675 portletIds.add(portletId);
\r
1677 Portlet portletModel = portletsPool.get(portletId);
\r
1679 if (portletModel == null) {
\r
1680 portletModel = new PortletImpl(CompanyConstants.SYSTEM, portletId);
\r
1682 portletsPool.put(portletId, portletModel);
\r
1685 portletModel.setTimestamp(timestamp);
\r
1687 portletModel.setPluginPackage(pluginPackage);
\r
1688 portletModel.setPortletApp(portletApp);
\r
1690 portletModel.setPortletName(portletName);
\r
1691 portletModel.setDisplayName(
\r
1692 GetterUtil.getString(
\r
1693 portletElement.elementText("display-name"),
\r
1694 portletModel.getDisplayName()));
\r
1695 portletModel.setPortletClass(
\r
1696 GetterUtil.getString(portletElement.elementText("portlet-class")));
\r
1698 Map<String, String> initParams = portletModel.getInitParams();
\r
1700 for (Element initParamElement : portletElement.elements("init-param")) {
\r
1702 initParamElement.elementText("name"),
\r
1703 initParamElement.elementText("value"));
\r
1706 Element expirationCacheElement = portletElement.element(
\r
1707 "expiration-cache");
\r
1709 if (expirationCacheElement != null) {
\r
1710 portletModel.setExpCache(
\r
1711 GetterUtil.getInteger(expirationCacheElement.getText()));
\r
1714 for (Element supportsElement : portletElement.elements("supports")) {
\r
1715 Map<String, Set<String>> portletModes =
\r
1716 portletModel.getPortletModes();
\r
1718 String mimeType = supportsElement.elementText("mime-type");
\r
1720 Set<String> mimeTypePortletModes = portletModes.get(mimeType);
\r
1722 if (mimeTypePortletModes == null) {
\r
1723 mimeTypePortletModes = new HashSet<String>();
\r
1725 portletModes.put(mimeType, mimeTypePortletModes);
\r
1728 mimeTypePortletModes.add(PortletMode.VIEW.toString().toLowerCase());
\r
1730 for (Element portletModeElement :
\r
1731 supportsElement.elements("portlet-mode")) {
\r
1733 mimeTypePortletModes.add(
\r
1734 portletModeElement.getTextTrim().toLowerCase());
\r
1737 Map<String, Set<String>> windowStates =
\r
1738 portletModel.getWindowStates();
\r
1740 Set<String> mimeTypeWindowStates = windowStates.get(mimeType);
\r
1742 if (mimeTypeWindowStates == null) {
\r
1743 mimeTypeWindowStates = new HashSet<String>();
\r
1745 windowStates.put(mimeType, mimeTypeWindowStates);
\r
1748 mimeTypeWindowStates.add(
\r
1749 WindowState.NORMAL.toString().toLowerCase());
\r
1751 List<Element> windowStateElements = supportsElement.elements(
\r
1754 if (windowStateElements.isEmpty()) {
\r
1755 mimeTypeWindowStates.add(
\r
1756 WindowState.MAXIMIZED.toString().toLowerCase());
\r
1757 mimeTypeWindowStates.add(
\r
1758 WindowState.MINIMIZED.toString().toLowerCase());
\r
1759 mimeTypeWindowStates.add(
\r
1760 LiferayWindowState.EXCLUSIVE.toString().toLowerCase());
\r
1761 mimeTypeWindowStates.add(
\r
1762 LiferayWindowState.POP_UP.toString().toLowerCase());
\r
1765 for (Element windowStateElement : windowStateElements) {
\r
1766 mimeTypeWindowStates.add(
\r
1767 windowStateElement.getTextTrim().toLowerCase());
\r
1771 Set<String> supportedLocales = portletModel.getSupportedLocales();
\r
1773 //supportedLocales.add(
\r
1774 // LocaleUtil.toLanguageId(LocaleUtil.getDefault()));
\r
1776 for (Element supportedLocaleElement : portletElement.elements(
\r
1777 "supported-locale")) {
\r
1779 String supportedLocale = supportedLocaleElement.getText();
\r
1781 supportedLocales.add(supportedLocale);
\r
1784 portletModel.setResourceBundle(
\r
1785 portletElement.elementText("resource-bundle"));
\r
1787 Element portletInfoElement = portletElement.element("portlet-info");
\r
1789 String portletInfoTitle = null;
\r
1790 String portletInfoShortTitle = null;
\r
1791 String portletInfoKeyWords = null;
\r
1792 String portletInfoDescription = null;
\r
1794 if (portletInfoElement != null) {
\r
1795 portletInfoTitle = portletInfoElement.elementText("title");
\r
1796 portletInfoShortTitle = portletInfoElement.elementText(
\r
1798 portletInfoKeyWords = portletInfoElement.elementText("keywords");
\r
1801 PortletInfo portletInfo = new PortletInfo(
\r
1802 portletInfoTitle, portletInfoShortTitle, portletInfoKeyWords,
\r
1803 portletInfoDescription);
\r
1805 portletModel.setPortletInfo(portletInfo);
\r
1807 Element portletPreferencesElement = portletElement.element(
\r
1808 "portlet-preferences");
\r
1810 String defaultPreferences = null;
\r
1811 String preferencesValidator = null;
\r
1813 if (portletPreferencesElement != null) {
\r
1814 Element preferencesValidatorElement =
\r
1815 portletPreferencesElement.element("preferences-validator");
\r
1817 if (preferencesValidatorElement != null) {
\r
1818 preferencesValidator = preferencesValidatorElement.getText();
\r
1820 portletPreferencesElement.remove(preferencesValidatorElement);
\r
1823 defaultPreferences = portletPreferencesElement.asXML();
\r
1826 portletModel.setDefaultPreferences(defaultPreferences);
\r
1827 portletModel.setPreferencesValidator(preferencesValidator);
\r
1829 if (!portletApp.isWARFile() &&
\r
1830 Validator.isNotNull(preferencesValidator) &&
\r
1831 PropsValues.PREFERENCE_VALIDATE_ON_STARTUP) {
\r
1834 PreferencesValidator preferencesValidatorObj =
\r
1835 PortalUtil.getPreferencesValidator(portletModel);
\r
1837 preferencesValidatorObj.validate(
\r
1838 PortletPreferencesFactoryUtil.fromDefaultXML(
\r
1839 defaultPreferences));
\r
1841 catch (Exception e) {
\r
1842 if (_log.isWarnEnabled()) {
\r
1844 "Portlet with the name " + portletId +
\r
1845 " does not have valid default preferences");
\r
1850 Set<String> unlikedRoles = portletModel.getUnlinkedRoles();
\r
1852 for (Element roleElement :
\r
1853 portletElement.elements("security-role-ref")) {
\r
1855 unlikedRoles.add(roleElement.elementText("role-name"));
\r
1858 for (Element supportedProcessingEventElement :
\r
1859 portletElement.elements("supported-processing-event")) {
\r
1861 Element qNameElement = supportedProcessingEventElement.element(
\r
1863 Element nameElement = supportedProcessingEventElement.element(
\r
1866 QName qName = PortletQNameUtil.getQName(
\r
1867 qNameElement, nameElement, portletApp.getDefaultNamespace());
\r
1869 portletModel.addProcessingEvent(qName);
\r
1872 for (Element supportedPublishingEventElement :
\r
1873 portletElement.elements("supported-publishing-event")) {
\r
1875 Element qNameElement = supportedPublishingEventElement.element(
\r
1877 Element nameElement = supportedPublishingEventElement.element(
\r
1880 QName qName = PortletQNameUtil.getQName(
\r
1881 qNameElement, nameElement, portletApp.getDefaultNamespace());
\r
1883 portletModel.addPublishingEvent(qName);
\r
1886 for (Element supportedPublicRenderParameter :
\r
1887 portletElement.elements("supported-public-render-parameter")) {
\r
1889 String identifier = supportedPublicRenderParameter.getTextTrim();
\r
1891 PublicRenderParameter publicRenderParameter =
\r
1892 portletApp.getPublicRenderParameter(identifier);
\r
1894 if (publicRenderParameter == null) {
\r
1896 "Supported public render parameter references " +
\r
1897 "unnknown identifier " + identifier);
\r
1902 portletModel.addPublicRenderParameter(publicRenderParameter);
\r
1906 private Set<String> _readPortletXML(
\r
1907 String servletContextName, ServletContext servletContext,
\r
1908 String xml, Map<String, Portlet> portletsPool,
\r
1909 Set<String> servletURLPatterns, PluginPackage pluginPackage)
\r
1910 throws Exception {
\r
1912 Set<String> portletIds = new HashSet<String>();
\r
1914 if (xml == null) {
\r
1915 return portletIds;
\r
1918 Document document = SAXReaderUtil.read(
\r
1919 xml, PropsValues.PORTLET_XML_VALIDATE);
\r
1921 Element rootElement = document.getRootElement();
\r
1923 PortletApp portletApp = _getPortletApp(servletContextName);
\r
1925 portletApp.addServletURLPatterns(servletURLPatterns);
\r
1927 Set<String> userAttributes = portletApp.getUserAttributes();
\r
1929 for (Element userAttributeElement :
\r
1930 rootElement.elements("user-attribute")) {
\r
1932 String name = userAttributeElement.elementText("name");
\r
1934 userAttributes.add(name);
\r
1937 String defaultNamespace = rootElement.elementText("default-namespace");
\r
1939 if (Validator.isNotNull(defaultNamespace)) {
\r
1940 portletApp.setDefaultNamespace(defaultNamespace);
\r
1943 for (Element eventDefinitionElement :
\r
1944 rootElement.elements("event-definition")) {
\r
1946 Element qNameElement = eventDefinitionElement.element("qname");
\r
1947 Element nameElement = eventDefinitionElement.element("name");
\r
1948 String valueType = eventDefinitionElement.elementText("value-type");
\r
1950 QName qName = PortletQNameUtil.getQName(
\r
1951 qNameElement, nameElement, portletApp.getDefaultNamespace());
\r
1953 EventDefinition eventDefinition = new EventDefinitionImpl(
\r
1954 qName, valueType, portletApp);
\r
1956 portletApp.addEventDefinition(eventDefinition);
\r
1959 for (Element publicRenderParameterElement :
\r
1960 rootElement.elements("public-render-parameter")) {
\r
1962 String identifier = publicRenderParameterElement.elementText(
\r
1964 Element qNameElement = publicRenderParameterElement.element(
\r
1966 Element nameElement = publicRenderParameterElement.element("name");
\r
1968 QName qName = PortletQNameUtil.getQName(
\r
1969 qNameElement, nameElement, portletApp.getDefaultNamespace());
\r
1971 PublicRenderParameter publicRenderParameter =
\r
1972 new PublicRenderParameterImpl(identifier, qName, portletApp);
\r
1974 portletApp.addPublicRenderParameter(publicRenderParameter);
\r
1977 for (Element containerRuntimeOptionElement :
\r
1978 rootElement.elements("container-runtime-option")) {
\r
1980 String name = GetterUtil.getString(
\r
1981 containerRuntimeOptionElement.elementText("name"));
\r
1983 List<String> values = new ArrayList<String>();
\r
1985 for (Element valueElement :
\r
1986 containerRuntimeOptionElement.elements("value")) {
\r
1988 values.add(valueElement.getTextTrim());
\r
1991 Map<String, String[]> containerRuntimeOptions =
\r
1992 portletApp.getContainerRuntimeOptions();
\r
1994 containerRuntimeOptions.put(
\r
1995 name, values.toArray(new String[values.size()]));
\r
1998 LiferayPortletConfig.RUNTIME_OPTION_PORTAL_CONTEXT) &&
\r
1999 !values.isEmpty() && GetterUtil.getBoolean(values.get(0))) {
\r
2001 portletApp.setWARFile(false);
\r
2005 long timestamp = ServletContextUtil.getLastModified(servletContext);
\r
2007 for (Element portletElement : rootElement.elements("portlet")) {
\r
2009 servletContextName, portletsPool, pluginPackage, portletApp,
\r
2010 portletIds, timestamp, portletElement);
\r
2013 for (Element filterElement : rootElement.elements("filter")) {
\r
2014 String filterName = filterElement.elementText("filter-name");
\r
2015 String filterClass = filterElement.elementText("filter-class");
\r
2017 Set<String> lifecycles = new LinkedHashSet<String>();
\r
2019 for (Element lifecycleElement :
\r
2020 filterElement.elements("lifecycle")) {
\r
2022 lifecycles.add(lifecycleElement.getText());
\r
2025 Map<String, String> initParams = new HashMap<String, String>();
\r
2027 for (Element initParamElement :
\r
2028 filterElement.elements("init-param")) {
\r
2031 initParamElement.elementText("name"),
\r
2032 initParamElement.elementText("value"));
\r
2035 PortletFilter portletFilter = new PortletFilterImpl(
\r
2036 filterName, filterClass, lifecycles, initParams, portletApp);
\r
2038 portletApp.addPortletFilter(portletFilter);
\r
2041 for (Element filterMappingElement :
\r
2042 rootElement.elements("filter-mapping")) {
\r
2044 String filterName = filterMappingElement.elementText("filter-name");
\r
2046 for (Element portletNameElement :
\r
2047 filterMappingElement.elements("portlet-name")) {
\r
2049 String portletName = portletNameElement.getTextTrim();
\r
2051 PortletFilter portletFilter = portletApp.getPortletFilter(
\r
2054 if (portletFilter == null) {
\r
2056 "Filter mapping references unnknown filter name " +
\r
2062 List<Portlet> portletModels = _getPortletsByPortletName(
\r
2063 portletName, servletContextName, portletsPool);
\r
2065 if (portletModels.size() == 0) {
\r
2067 "Filter mapping with filter name " + filterName +
\r
2068 " references unnknown portlet name " + portletName);
\r
2071 for (Portlet portletModel : portletModels) {
\r
2072 portletModel.getPortletFilters().put(
\r
2073 filterName, portletFilter);
\r
2078 for (Element listenerElement : rootElement.elements("listener")) {
\r
2079 String listenerClass = listenerElement.elementText(
\r
2080 "listener-class");
\r
2082 PortletURLListener portletURLListener = new PortletURLListenerImpl(
\r
2083 listenerClass, portletApp);
\r
2085 portletApp.addPortletURLListener(portletURLListener);
\r
2088 return portletIds;
\r
2091 private Set<String> _readWebXML(String xml) throws Exception {
\r
2092 Set<String> servletURLPatterns = new LinkedHashSet<String>();
\r
2094 if (xml == null) {
\r
2095 return servletURLPatterns;
\r
2098 Document document = SAXReaderUtil.read(xml);
\r
2100 Element rootElement = document.getRootElement();
\r
2102 for (Element servletMappingElement :
\r
2103 rootElement.elements("servlet-mapping")) {
\r
2105 String urlPattern = servletMappingElement.elementText(
\r
2108 servletURLPatterns.add(urlPattern);
\r
2111 return servletURLPatterns;
\r
2114 private void _setSpriteImages(
\r
2115 ServletContext servletContext, PortletApp portletApp,
\r
2116 String resourcePath)
\r
2117 throws Exception {
\r
2119 Set<String> resourcePaths = servletContext.getResourcePaths(
\r
2122 if (resourcePaths == null) {
\r
2126 List<File> imageFiles = new ArrayList<File>(resourcePaths.size());
\r
2128 for (String curResourcePath : resourcePaths) {
\r
2129 if (curResourcePath.endsWith(StringPool.SLASH)) {
\r
2130 _setSpriteImages(servletContext, portletApp, curResourcePath);
\r
2132 else if (curResourcePath.endsWith(".png")) {
\r
2133 String realPath = ServletContextUtil.getRealPath(
\r
2134 servletContext, curResourcePath);
\r
2136 if (realPath != null) {
\r
2137 File imageFile = new File(realPath);
\r
2139 imageFiles.add(imageFile);
\r
2142 if (ServerDetector.isTomcat()) {
\r
2143 if (_log.isInfoEnabled()) {
\r
2144 _log.info(ServletContextUtil.LOG_INFO_SPRITES);
\r
2149 "Real path for " + curResourcePath + " is null");
\r
2155 String spriteFileName = PropsValues.SPRITE_FILE_NAME;
\r
2156 String spritePropertiesFileName =
\r
2157 PropsValues.SPRITE_PROPERTIES_FILE_NAME;
\r
2158 String spritePropertiesRootPath = ServletContextUtil.getRealPath(
\r
2159 servletContext, StringPool.SLASH);
\r
2161 Properties spriteProperties = SpriteProcessorUtil.generate(
\r
2162 servletContext, imageFiles, spriteFileName,
\r
2163 spritePropertiesFileName, spritePropertiesRootPath, 16, 16, 10240);
\r
2165 if (spriteProperties == null) {
\r
2170 resourcePath.substring(0, resourcePath.length()) + spriteFileName;
\r
2172 portletApp.setSpriteImages(spriteFileName, spriteProperties);
\r
2175 private static Log _log = LogFactoryUtil.getLog(
\r
2176 PortletLocalServiceImpl.class);
\r
2178 private static Map<Long, Map<String, Portlet>> _companyPortletsPool =
\r
2179 new ConcurrentHashMap<Long, Map<String, Portlet>>();
\r
2180 private static Map<String, Portlet> _customAttributesDisplayPortlets =
\r
2181 new ConcurrentHashMap<String, Portlet>();
\r
2182 private static Map<String, Portlet> _friendlyURLMapperPortlets =
\r
2183 new ConcurrentHashMap<String, Portlet>();
\r
2184 private static Map<String, PortletApp> _portletAppsPool =
\r
2185 new ConcurrentHashMap<String, PortletApp>();
\r
2186 private static Map<String, String> _portletIdsByStrutsPath =
\r
2187 new ConcurrentHashMap<String, String>();
\r
2188 private static Map<String, Portlet> _portletsPool =
\r
2189 new ConcurrentHashMap<String, Portlet>();
\r