001
014
015 package com.liferay.portal.service.impl;
016
017 import com.liferay.portal.PortletIdException;
018 import com.liferay.portal.kernel.application.type.ApplicationType;
019 import com.liferay.portal.kernel.cluster.Clusterable;
020 import com.liferay.portal.kernel.configuration.Configuration;
021 import com.liferay.portal.kernel.configuration.ConfigurationFactoryUtil;
022 import com.liferay.portal.kernel.exception.PortalException;
023 import com.liferay.portal.kernel.exception.SystemException;
024 import com.liferay.portal.kernel.image.SpriteProcessor;
025 import com.liferay.portal.kernel.image.SpriteProcessorUtil;
026 import com.liferay.portal.kernel.log.Log;
027 import com.liferay.portal.kernel.log.LogFactoryUtil;
028 import com.liferay.portal.kernel.plugin.PluginPackage;
029 import com.liferay.portal.kernel.portlet.FriendlyURLMapper;
030 import com.liferay.portal.kernel.portlet.LiferayPortletConfig;
031 import com.liferay.portal.kernel.portlet.LiferayWindowState;
032 import com.liferay.portal.kernel.portlet.PortletLayoutListener;
033 import com.liferay.portal.kernel.portlet.PortletProvider;
034 import com.liferay.portal.kernel.portlet.PortletProviderUtil;
035 import com.liferay.portal.kernel.scheduler.SchedulerEntryImpl;
036 import com.liferay.portal.kernel.scheduler.TimeUnit;
037 import com.liferay.portal.kernel.scheduler.TriggerFactoryUtil;
038 import com.liferay.portal.kernel.servlet.ServletContextUtil;
039 import com.liferay.portal.kernel.spring.aop.Skip;
040 import com.liferay.portal.kernel.transaction.Transactional;
041 import com.liferay.portal.kernel.util.CharPool;
042 import com.liferay.portal.kernel.util.ClassLoaderPool;
043 import com.liferay.portal.kernel.util.ContentTypes;
044 import com.liferay.portal.kernel.util.GetterUtil;
045 import com.liferay.portal.kernel.util.ListUtil;
046 import com.liferay.portal.kernel.util.StringPool;
047 import com.liferay.portal.kernel.util.StringUtil;
048 import com.liferay.portal.kernel.util.Validator;
049 import com.liferay.portal.kernel.xml.Document;
050 import com.liferay.portal.kernel.xml.Element;
051 import com.liferay.portal.kernel.xml.QName;
052 import com.liferay.portal.kernel.xml.UnsecureSAXReaderUtil;
053 import com.liferay.portal.model.CompanyConstants;
054 import com.liferay.portal.model.EventDefinition;
055 import com.liferay.portal.model.Portlet;
056 import com.liferay.portal.model.PortletApp;
057 import com.liferay.portal.model.PortletCategory;
058 import com.liferay.portal.model.PortletConstants;
059 import com.liferay.portal.model.PortletFilter;
060 import com.liferay.portal.model.PortletInfo;
061 import com.liferay.portal.model.PortletInstance;
062 import com.liferay.portal.model.PortletPreferences;
063 import com.liferay.portal.model.PortletURLListener;
064 import com.liferay.portal.model.PublicRenderParameter;
065 import com.liferay.portal.model.ResourceConstants;
066 import com.liferay.portal.model.Role;
067 import com.liferay.portal.model.impl.EventDefinitionImpl;
068 import com.liferay.portal.model.impl.PortletAppImpl;
069 import com.liferay.portal.model.impl.PortletFilterImpl;
070 import com.liferay.portal.model.impl.PortletImpl;
071 import com.liferay.portal.model.impl.PortletURLListenerImpl;
072 import com.liferay.portal.model.impl.PublicRenderParameterImpl;
073 import com.liferay.portal.security.permission.ActionKeys;
074 import com.liferay.portal.security.permission.ResourceActionsUtil;
075 import com.liferay.portal.service.base.PortletLocalServiceBaseImpl;
076 import com.liferay.portal.service.permission.PortletPermissionUtil;
077 import com.liferay.portal.servlet.ComboServlet;
078 import com.liferay.portal.util.PortalUtil;
079 import com.liferay.portal.util.PortletKeys;
080 import com.liferay.portal.util.PropsValues;
081 import com.liferay.portal.util.WebAppPool;
082 import com.liferay.portal.util.WebKeys;
083 import com.liferay.portlet.PortletBagFactory;
084 import com.liferay.portlet.PortletConfigFactoryUtil;
085 import com.liferay.portlet.PortletContextFactory;
086 import com.liferay.portlet.PortletInstanceFactoryUtil;
087 import com.liferay.portlet.PortletPreferencesFactoryUtil;
088 import com.liferay.portlet.PortletQNameUtil;
089 import com.liferay.portlet.UndeployedPortlet;
090 import com.liferay.portlet.admin.util.PortalMyAccountApplicationType;
091 import com.liferay.portlet.expando.model.CustomAttributesDisplay;
092 import com.liferay.util.ContentUtil;
093
094 import java.net.URL;
095
096 import java.util.ArrayList;
097 import java.util.Collections;
098 import java.util.HashMap;
099 import java.util.HashSet;
100 import java.util.Iterator;
101 import java.util.LinkedHashSet;
102 import java.util.List;
103 import java.util.Map;
104 import java.util.Properties;
105 import java.util.Set;
106 import java.util.concurrent.ConcurrentHashMap;
107
108 import javax.portlet.PortletMode;
109 import javax.portlet.PreferencesValidator;
110 import javax.portlet.WindowState;
111
112 import javax.servlet.ServletContext;
113
114
121 public class PortletLocalServiceImpl extends PortletLocalServiceBaseImpl {
122
123 @Override
124 @Skip
125 public void addPortletCategory(long companyId, String categoryName) {
126 PortletCategory portletCategory = (PortletCategory)WebAppPool.get(
127 companyId, WebKeys.PORTLET_CATEGORY);
128
129 if (portletCategory == null) {
130 _log.error(
131 "Unable to add portlet category for company " + companyId +
132 " because it does not exist");
133
134 return;
135 }
136
137 PortletCategory newPortletCategory = new PortletCategory(categoryName);
138
139 if (newPortletCategory.getParentCategory() == null) {
140 PortletCategory rootPortletCategory = new PortletCategory();
141
142 rootPortletCategory.addCategory(newPortletCategory);
143 }
144
145 portletCategory.merge(newPortletCategory.getRootCategory());
146 }
147
148 @Override
149 public void checkPortlet(Portlet portlet) throws PortalException {
150 long companyId = portlet.getCompanyId();
151 String name = portlet.getRootPortletId();
152
153 int resourcePermissionsCount =
154 resourcePermissionLocalService.getResourcePermissionsCount(
155 companyId, name, ResourceConstants.SCOPE_INDIVIDUAL, name);
156
157 if (resourcePermissionsCount == 0) {
158 resourceLocalService.addResources(
159 companyId, 0, 0, name, name, true, false, false);
160 }
161
162 if (portlet.isSystem()) {
163 return;
164 }
165
166 String[] roleNames = portlet.getRolesArray();
167
168 if (roleNames.length == 0) {
169 return;
170 }
171
172 int scope = ResourceConstants.SCOPE_COMPANY;
173 String primKey = String.valueOf(companyId);
174 String actionId = ActionKeys.ADD_TO_PAGE;
175
176 List<String> actionIds = ResourceActionsUtil.getPortletResourceActions(
177 name);
178
179 if (actionIds.contains(actionId)) {
180 for (String roleName : roleNames) {
181 Role role = roleLocalService.getRole(companyId, roleName);
182
183 resourcePermissionLocalService.addResourcePermission(
184 companyId, name, scope, primKey, role.getRoleId(),
185 actionId);
186 }
187 }
188
189 updatePortlet(
190 companyId, portlet.getPortletId(), StringPool.BLANK,
191 portlet.isActive());
192 }
193
194 @Override
195 public void checkPortlets(long companyId) throws PortalException {
196 List<Portlet> portlets = getPortlets(companyId);
197
198 for (Portlet portlet : portlets) {
199 checkPortlet(portlet);
200 }
201 }
202
203 @Override
204 @Skip
205 public void clearCache() {
206
207
208
209 ComboServlet.clearCache();
210
211
212
213 _portletIdsByStrutsPath.clear();
214
215
216
217 portletLocalService.clearPortletsMap();
218 }
219
220
223 @Clusterable
224 @Deprecated
225 @Override
226 @Transactional(enabled = false)
227 public void clearCompanyPortletsPool() {
228 _portletsMaps.clear();
229 }
230
231 @Clusterable
232 @Override
233 @Transactional(enabled = false)
234 public void clearPortletsMap() {
235 _portletsMaps.clear();
236 }
237
238
241 @Deprecated
242 @Override
243 @Skip
244 public Portlet clonePortlet(long companyId, String portletId) {
245 return clonePortlet(portletId);
246 }
247
248 @Override
249 @Skip
250 public Portlet clonePortlet(String portletId) {
251 Portlet portlet = getPortletById(portletId);
252
253 return (Portlet)portlet.clone();
254 }
255
256 @Override
257 public void deletePortlet(long companyId, String portletId, long plid)
258 throws PortalException {
259
260 String rootPortletId = PortletConstants.getRootPortletId(portletId);
261
262 resourceLocalService.deleteResource(
263 companyId, rootPortletId, ResourceConstants.SCOPE_INDIVIDUAL,
264 PortletPermissionUtil.getPrimaryKey(plid, portletId));
265
266 int ownerType = PortletKeys.PREFS_OWNER_TYPE_LAYOUT;
267
268 if (PortletConstants.hasUserId(portletId)) {
269 ownerType = PortletKeys.PREFS_OWNER_TYPE_USER;
270 }
271
272 List<PortletPreferences> portletPreferencesList =
273 portletPreferencesLocalService.getPortletPreferences(
274 ownerType, plid, portletId);
275
276 Portlet portlet = getPortletById(companyId, portletId);
277
278 PortletLayoutListener portletLayoutListener = null;
279
280 if (portlet != null) {
281 portletLayoutListener = portlet.getPortletLayoutListenerInstance();
282
283 PortletInstanceFactoryUtil.delete(portlet);
284 }
285
286 for (PortletPreferences portletPreferences : portletPreferencesList) {
287 if (portletLayoutListener != null) {
288 portletLayoutListener.onRemoveFromLayout(
289 portletPreferences.getPortletId(), plid);
290 }
291
292 portletPreferencesLocalService.deletePortletPreferences(
293 portletPreferences.getPortletPreferencesId());
294 }
295 }
296
297 @Override
298 public void deletePortlets(long companyId, String[] portletIds, long plid)
299 throws PortalException {
300
301 for (String portletId : portletIds) {
302 deletePortlet(companyId, portletId, plid);
303 }
304 }
305
306 @Override
307 public Portlet deployRemotePortlet(Portlet portlet, String categoryName)
308 throws PortalException {
309
310 return deployRemotePortlet(portlet, new String[] {categoryName});
311 }
312
313 @Override
314 public Portlet deployRemotePortlet(Portlet portlet, String[] categoryNames)
315 throws PortalException {
316
317 return deployRemotePortlet(portlet, categoryNames, true);
318 }
319
320 @Override
321 public Portlet deployRemotePortlet(
322 Portlet portlet, String[] categoryNames, boolean eagerDestroy)
323 throws PortalException {
324
325 _portletsMap.put(portlet.getPortletId(), portlet);
326
327 if (eagerDestroy) {
328 PortletInstanceFactoryUtil.clear(portlet, false);
329
330 PortletConfigFactoryUtil.destroy(portlet);
331 }
332
333 clearCache();
334
335 List<String> portletActions =
336 ResourceActionsUtil.getPortletResourceActions(
337 portlet.getPortletId());
338
339 resourceActionLocalService.checkResourceActions(
340 portlet.getPortletId(), portletActions);
341
342 PortletCategory portletCategory = (PortletCategory)WebAppPool.get(
343 portlet.getCompanyId(), WebKeys.PORTLET_CATEGORY);
344
345 if (portletCategory == null) {
346 _log.error(
347 "Unable to register remote portlet for company " +
348 portlet.getCompanyId() + " because it does not exist");
349
350 return portlet;
351 }
352
353 portletCategory.separate(portlet.getPortletId());
354
355 for (String categoryName : categoryNames) {
356 PortletCategory newPortletCategory = new PortletCategory(
357 categoryName);
358
359 if (newPortletCategory.getParentCategory() == null) {
360 PortletCategory rootPortletCategory = new PortletCategory();
361
362 rootPortletCategory.addCategory(newPortletCategory);
363 }
364
365 Set<String> portletIds = newPortletCategory.getPortletIds();
366
367 portletIds.add(portlet.getPortletId());
368
369 portletCategory.merge(newPortletCategory.getRootCategory());
370 }
371
372 checkPortlet(portlet);
373
374 return portlet;
375 }
376
377 @Override
378 @Skip
379 public void destroyPortlet(Portlet portlet) {
380 _portletsMap.remove(portlet.getRootPortletId());
381
382 PortletApp portletApp = portlet.getPortletApp();
383
384 if (portletApp != null) {
385 _portletApps.remove(portletApp.getServletContextName());
386 }
387
388 clearCache();
389 }
390
391 @Override
392 @Skip
393 public void destroyRemotePortlet(Portlet portlet) {
394 destroyPortlet(portlet);
395 }
396
397 @Override
398 @Skip
399 public List<CustomAttributesDisplay> getCustomAttributesDisplays() {
400 List<CustomAttributesDisplay> customAttributesDisplays =
401 new ArrayList<>();
402
403 for (Portlet portlet : getPortlets()) {
404 if (!portlet.isActive() || !portlet.isInclude() ||
405 !portlet.isReady() || portlet.isUndeployedPortlet()) {
406
407 continue;
408 }
409
410 List<CustomAttributesDisplay> portletCustomAttributesDisplays =
411 portlet.getCustomAttributesDisplayInstances();
412
413 if ((portletCustomAttributesDisplays != null) &&
414 !portletCustomAttributesDisplays.isEmpty()) {
415
416 customAttributesDisplays.addAll(
417 portletCustomAttributesDisplays);
418 }
419 }
420
421 return customAttributesDisplays;
422 }
423
424 @Override
425 @Skip
426 public PortletCategory getEARDisplay(String xml) {
427 try {
428 return _readLiferayDisplayXML(xml);
429 }
430 catch (Exception e) {
431 throw new SystemException(e);
432 }
433 }
434
435 @Override
436 @Skip
437 public List<Portlet> getFriendlyURLMapperPortlets() {
438 List<Portlet> portlets = new ArrayList<>();
439
440 for (Portlet portlet : getPortlets()) {
441 if (!portlet.isActive() || !portlet.isInclude() ||
442 !portlet.isReady() || portlet.isUndeployedPortlet()) {
443
444 continue;
445 }
446
447 FriendlyURLMapper friendlyURLMapper =
448 portlet.getFriendlyURLMapperInstance();
449
450 if (friendlyURLMapper != null) {
451 portlets.add(portlet);
452 }
453 }
454
455 return portlets;
456 }
457
458 @Override
459 @Skip
460 public List<FriendlyURLMapper> getFriendlyURLMappers() {
461 List<FriendlyURLMapper> friendlyURLMappers = new ArrayList<>();
462
463 for (Portlet portlet : getPortlets()) {
464 if (!portlet.isActive() || !portlet.isInclude() ||
465 !portlet.isReady() || portlet.isUndeployedPortlet()) {
466
467 continue;
468 }
469
470 FriendlyURLMapper friendlyURLMapper =
471 portlet.getFriendlyURLMapperInstance();
472
473 if (friendlyURLMapper != null) {
474 friendlyURLMappers.add(friendlyURLMapper);
475 }
476 }
477
478 return friendlyURLMappers;
479 }
480
481 @Override
482 @Skip
483 public PortletApp getPortletApp(String servletContextName) {
484 PortletApp portletApp = _portletApps.get(servletContextName);
485
486 if (portletApp == null) {
487 portletApp = new PortletAppImpl(servletContextName);
488
489 _portletApps.put(servletContextName, portletApp);
490 }
491
492 return portletApp;
493 }
494
495 @Override
496 @Skip
497 public Portlet getPortletById(long companyId, String portletId) {
498 portletId = PortalUtil.getJsSafePortletId(portletId);
499
500 Portlet portlet = null;
501
502 Map<String, Portlet> companyPortletsMap = _getPortletsMap(companyId);
503
504 String rootPortletId = PortletConstants.getRootPortletId(portletId);
505
506 if (portletId.equals(rootPortletId)) {
507 portlet = companyPortletsMap.get(portletId);
508 }
509 else {
510 portlet = companyPortletsMap.get(rootPortletId);
511
512 if (portlet != null) {
513 portlet = portlet.getClonedInstance(portletId);
514 }
515 }
516
517 if (portlet != null) {
518 return portlet;
519 }
520
521 if (portletId.equals(PortletKeys.LIFERAY_PORTAL)) {
522 return portlet;
523 }
524
525 if (_portletsMap.isEmpty()) {
526 if (_log.isDebugEnabled()) {
527 _log.debug("No portlets are installed");
528 }
529 }
530 else {
531 if (_log.isInfoEnabled()) {
532 _log.info(
533 "Portlet not found for " + companyId + " " + portletId);
534 }
535
536 portlet = new PortletImpl(CompanyConstants.SYSTEM, portletId);
537
538 PortletApp portletApp = getPortletApp(StringPool.BLANK);
539
540 portlet.setPortletApp(portletApp);
541
542 portlet.setPortletName(portletId);
543 portlet.setDisplayName(portletId);
544 portlet.setPortletClass(UndeployedPortlet.class.getName());
545
546 Set<String> mimeTypePortletModes = new HashSet<>();
547
548 mimeTypePortletModes.add(
549 StringUtil.toLowerCase(PortletMode.VIEW.toString()));
550
551 Map<String, Set<String>> portletModes = portlet.getPortletModes();
552
553 portletModes.put(ContentTypes.TEXT_HTML, mimeTypePortletModes);
554
555 Set<String> mimeTypeWindowStates = new HashSet<>();
556
557 mimeTypeWindowStates.add(
558 StringUtil.toLowerCase(WindowState.NORMAL.toString()));
559
560 Map<String, Set<String>> windowStates = portlet.getWindowStates();
561
562 windowStates.put(ContentTypes.TEXT_HTML, mimeTypeWindowStates);
563
564 portlet.setPortletInfo(
565 new PortletInfo(portletId, portletId, portletId, portletId));
566
567 if (PortletConstants.hasInstanceId(portletId)) {
568 portlet.setInstanceable(true);
569 }
570
571 portlet.setActive(true);
572 portlet.setUndeployedPortlet(true);
573 }
574
575 return portlet;
576 }
577
578 @Override
579 @Skip
580 public Portlet getPortletById(String portletId) {
581 return _portletsMap.get(PortletConstants.getRootPortletId(portletId));
582 }
583
584 @Override
585 @Skip
586 public Portlet getPortletByStrutsPath(long companyId, String strutsPath) {
587 return getPortletById(companyId, _getPortletId(strutsPath));
588 }
589
590 @Override
591 @Skip
592 public List<Portlet> getPortlets() {
593 return ListUtil.fromMapValues(_portletsMap);
594 }
595
596 @Override
597 @Skip
598 public List<Portlet> getPortlets(long companyId) {
599 return getPortlets(companyId, true, true);
600 }
601
602 @Override
603 @Skip
604 public List<Portlet> getPortlets(
605 long companyId, boolean showSystem, boolean showPortal) {
606
607 Map<String, Portlet> portletsMap = _getPortletsMap(companyId);
608
609 List<Portlet> portlets = ListUtil.fromMapValues(portletsMap);
610
611 if (showSystem && showPortal) {
612 return portlets;
613 }
614
615 Iterator<Portlet> itr = portlets.iterator();
616
617 while (itr.hasNext()) {
618 Portlet portlet = itr.next();
619
620 if (showPortal &&
621 portlet.getPortletId().equals(PortletKeys.PORTAL)) {
622 }
623 else if (!showPortal &&
624 portlet.getPortletId().equals(PortletKeys.PORTAL)) {
625
626 itr.remove();
627 }
628 else if (!showSystem && portlet.isSystem()) {
629 itr.remove();
630 }
631 }
632
633 return portlets;
634 }
635
636 @Override
637 @Skip
638 public List<Portlet> getScopablePortlets() {
639 List<Portlet> portlets = ListUtil.fromMapValues(_portletsMap);
640
641 Iterator<Portlet> itr = portlets.iterator();
642
643 while (itr.hasNext()) {
644 Portlet portlet = itr.next();
645
646 if (!portlet.isScopeable()) {
647 itr.remove();
648 }
649 }
650
651 return portlets;
652 }
653
654 @Override
655 @Skip
656 public PortletCategory getWARDisplay(
657 String servletContextName, String xml) {
658
659 try {
660 return _readLiferayDisplayXML(servletContextName, xml);
661 }
662 catch (Exception e) {
663 throw new SystemException(e);
664 }
665 }
666
667 @Override
668 @Skip
669 public boolean hasPortlet(long companyId, String portletId) {
670 portletId = PortalUtil.getJsSafePortletId(portletId);
671
672 Portlet portlet = null;
673
674 Map<String, Portlet> companyPortletsMap = _getPortletsMap(companyId);
675
676 String rootPortletId = PortletConstants.getRootPortletId(portletId);
677
678 if (portletId.equals(rootPortletId)) {
679 portlet = companyPortletsMap.get(portletId);
680 }
681 else {
682 portlet = companyPortletsMap.get(rootPortletId);
683 }
684
685 if (portlet == null) {
686 return false;
687 }
688 else {
689 return true;
690 }
691 }
692
693 @Override
694 @Skip
695 public void initEAR(
696 ServletContext servletContext, String[] xmls,
697 PluginPackage pluginPackage) {
698
699
700
701 portletLocalService.clearPortletsMap();
702
703 _portletApps.clear();
704 _portletsMap.clear();
705 _portletIdsByStrutsPath.clear();
706
707 try {
708 PortletApp portletApp = getPortletApp(StringPool.BLANK);
709
710 portletApp.setServletContext(servletContext);
711
712 Set<String> servletURLPatterns = _readWebXML(xmls[4]);
713
714 Map<String, Portlet> portletsMap = _readPortletXML(
715 StringPool.BLANK, servletContext, xmls[0], servletURLPatterns,
716 pluginPackage);
717
718 portletsMap.putAll(
719 _readPortletXML(
720 StringPool.BLANK, servletContext, xmls[1],
721 servletURLPatterns, pluginPackage));
722
723 for (Map.Entry<String, Portlet> entry : portletsMap.entrySet()) {
724 _portletsMap.put(entry.getKey(), entry.getValue());
725 }
726
727 Set<String> liferayPortletIds = _readLiferayPortletXML(
728 StringPool.BLANK, servletContext, xmls[2], portletsMap);
729
730 liferayPortletIds.addAll(
731 _readLiferayPortletXML(
732 StringPool.BLANK, servletContext, xmls[3], portletsMap));
733
734
735
736 for (String portletId : portletsMap.keySet()) {
737 if (_log.isWarnEnabled() &&
738 !liferayPortletIds.contains(portletId)) {
739
740 _log.warn(
741 "Portlet with the name " + portletId +
742 " is described in portlet.xml but does not " +
743 "have a matching entry in liferay-portlet.xml");
744 }
745 }
746
747
748
749 for (String portletId : liferayPortletIds) {
750 if (_log.isWarnEnabled() &&
751 !portletsMap.containsKey(portletId)) {
752
753 _log.warn(
754 "Portlet with the name " + portletId +
755 " is described in liferay-portlet.xml but does " +
756 "not have a matching entry in portlet.xml");
757 }
758 }
759
760
761
762 Iterator<Map.Entry<String, Portlet>> portletPoolsItr =
763 _portletsMap.entrySet().iterator();
764
765 while (portletPoolsItr.hasNext()) {
766 Map.Entry<String, Portlet> entry = portletPoolsItr.next();
767
768 Portlet portletModel = entry.getValue();
769
770 String portletId = PortletProviderUtil.getPortletId(
771 PortalMyAccountApplicationType.MyAccount.CLASS_NAME,
772 PortletProvider.Action.VIEW);
773
774 if (!Validator.equals(
775 portletModel.getPortletId(),
776 PortletKeys.SERVER_ADMIN) &&
777 !Validator.equals(portletModel.getPortletId(), portletId) &&
778 !portletModel.isInclude()) {
779
780 portletPoolsItr.remove();
781 }
782 }
783
784
785
786 _setSpriteImages(servletContext, portletApp, "/html/icons/");
787 }
788 catch (Exception e) {
789 _log.error(e, e);
790 }
791 }
792
793 @Override
794 @Skip
795 public List<Portlet> initWAR(
796 String servletContextName, ServletContext servletContext, String[] xmls,
797 PluginPackage pluginPackage) {
798
799 Map<String, Portlet> portletsMap = null;
800
801 Set<String> liferayPortletIds = null;
802
803 try {
804 Set<String> servletURLPatterns = _readWebXML(xmls[3]);
805
806 portletsMap = _readPortletXML(
807 servletContextName, servletContext, xmls[0], servletURLPatterns,
808 pluginPackage);
809
810 portletsMap.putAll(
811 _readPortletXML(
812 servletContextName, servletContext, xmls[1],
813 servletURLPatterns, pluginPackage));
814
815 liferayPortletIds = _readLiferayPortletXML(
816 servletContextName, servletContext, xmls[2], portletsMap);
817 }
818 catch (Exception e) {
819 _log.error(e, e);
820
821 return Collections.emptyList();
822 }
823
824
825
826 for (String portletId : portletsMap.keySet()) {
827 if (_log.isWarnEnabled() &&
828 !liferayPortletIds.contains(portletId)) {
829
830 _log.warn(
831 "Portlet with the name " + portletId +
832 " is described in portlet.xml but does not " +
833 "have a matching entry in liferay-portlet.xml");
834 }
835 }
836
837
838
839 for (String portletId : liferayPortletIds) {
840 if (_log.isWarnEnabled() && !portletsMap.containsKey(portletId)) {
841 _log.warn(
842 "Portlet with the name " + portletId +
843 " is described in liferay-portlet.xml but does " +
844 "not have a matching entry in portlet.xml");
845 }
846 }
847
848 PortletBagFactory portletBagFactory = new PortletBagFactory();
849
850 portletBagFactory.setClassLoader(
851 ClassLoaderPool.getClassLoader(servletContextName));
852 portletBagFactory.setServletContext(servletContext);
853 portletBagFactory.setWARFile(true);
854
855
856
857 try {
858 for (Map.Entry<String, Portlet> entry : portletsMap.entrySet()) {
859 Portlet portlet = _portletsMap.remove(entry.getKey());
860
861 if (portlet != null) {
862 PortletInstanceFactoryUtil.clear(portlet);
863
864 PortletConfigFactoryUtil.destroy(portlet);
865 PortletContextFactory.destroy(portlet);
866 }
867
868 portlet = entry.getValue();
869
870 _portletsMap.put(entry.getKey(), portlet);
871
872 portletBagFactory.create(portlet);
873 }
874
875
876
877 PortletApp portletApp = getPortletApp(servletContextName);
878
879 _setSpriteImages(servletContext, portletApp, "/icons/");
880
881 return ListUtil.fromMapValues(portletsMap);
882 }
883 catch (Exception e) {
884 _log.error(e, e);
885
886
887
888 for (Map.Entry<String, Portlet> entry : portletsMap.entrySet()) {
889 Portlet portlet = _portletsMap.remove(entry.getKey());
890
891 if (portlet != null) {
892 PortletInstanceFactoryUtil.clear(portlet);
893
894 PortletConfigFactoryUtil.destroy(portlet);
895 PortletContextFactory.destroy(portlet);
896 }
897 }
898
899 return Collections.emptyList();
900 }
901 finally {
902 clearCache();
903 }
904 }
905
906 @Override
907 public Map<String, Portlet> loadGetPortletsMap(long companyId) {
908 Map<String, Portlet> portletsMap = new ConcurrentHashMap<>();
909
910 for (Portlet portlet : _portletsMap.values()) {
911 portlet = (Portlet)portlet.clone();
912
913 portlet.setCompanyId(companyId);
914
915 portletsMap.put(portlet.getPortletId(), portlet);
916 }
917
918 List<Portlet> portlets = portletPersistence.findByCompanyId(companyId);
919
920 for (Portlet portlet : portlets) {
921 Portlet portletModel = portletsMap.get(portlet.getPortletId());
922
923
924
925
926 if (portletModel != null) {
927 portletModel.setPluginPackage(portlet.getPluginPackage());
928 portletModel.setDefaultPluginSetting(
929 portlet.getDefaultPluginSetting());
930 portletModel.setRoles(portlet.getRoles());
931 portletModel.setActive(portlet.getActive());
932 }
933 }
934
935 return portletsMap;
936 }
937
938
941 @Deprecated
942 @Override
943 public Map<String, Portlet> loadGetPortletsPool(long companyId) {
944 return loadGetPortletsMap(companyId);
945 }
946
947 @Clusterable
948 @Override
949 @Transactional(enabled = false)
950 public void removeCompanyPortletsPool(long companyId) {
951 _portletsMaps.remove(companyId);
952 }
953
954 @Override
955 public Portlet updatePortlet(
956 long companyId, String portletId, String roles, boolean active) {
957
958 portletId = PortalUtil.getJsSafePortletId(portletId);
959
960 Portlet portlet = portletPersistence.fetchByC_P(companyId, portletId);
961
962 if (portlet == null) {
963 long id = counterLocalService.increment();
964
965 portlet = portletPersistence.create(id);
966
967 portlet.setCompanyId(companyId);
968 portlet.setPortletId(portletId);
969 }
970
971 portlet.setRoles(roles);
972 portlet.setActive(active);
973
974 portletPersistence.update(portlet);
975
976 portlet = getPortletById(companyId, portletId);
977
978 portlet.setRoles(roles);
979 portlet.setActive(active);
980
981 portletLocalService.removeCompanyPortletsPool(companyId);
982
983 return portlet;
984 }
985
986 private String _getPortletId(String securityPath) {
987 if (_portletIdsByStrutsPath.isEmpty()) {
988 for (Portlet portlet : _portletsMap.values()) {
989 String strutsPath = portlet.getStrutsPath();
990
991 if (_portletIdsByStrutsPath.containsKey(strutsPath)) {
992 if (_log.isWarnEnabled()) {
993 _log.warn("Duplicate struts path " + strutsPath);
994 }
995 }
996
997 _portletIdsByStrutsPath.put(strutsPath, portlet.getPortletId());
998 }
999 }
1000
1001 String portletId = _portletIdsByStrutsPath.get(securityPath);
1002
1003 if (Validator.isNull(portletId)) {
1004 for (String strutsPath : _portletIdsByStrutsPath.keySet()) {
1005 if (securityPath.startsWith(
1006 strutsPath.concat(StringPool.SLASH))) {
1007
1008 portletId = _portletIdsByStrutsPath.get(strutsPath);
1009
1010 break;
1011 }
1012 }
1013 }
1014
1015 if (Validator.isNull(portletId)) {
1016 _log.error(
1017 "Struts path " + securityPath + " is not mapped to a portlet " +
1018 "in liferay-portlet.xml");
1019 }
1020
1021 return portletId;
1022 }
1023
1024 private List<Portlet> _getPortletsByPortletName(
1025 String portletName, String servletContextName,
1026 Map<String, Portlet> portletsMap) {
1027
1028 int pos = portletName.indexOf(CharPool.STAR);
1029
1030 if (pos == -1) {
1031 String portletId = portletName;
1032
1033 if (Validator.isNotNull(servletContextName)) {
1034 portletId =
1035 portletId + PortletConstants.WAR_SEPARATOR +
1036 servletContextName;
1037 }
1038
1039 portletId = PortalUtil.getJsSafePortletId(portletId);
1040
1041 Portlet portlet = portletsMap.get(portletId);
1042
1043 if (portlet == null) {
1044 return Collections.emptyList();
1045 }
1046
1047 return Collections.singletonList(portlet);
1048 }
1049
1050 return _getPortletsByServletContextName(
1051 servletContextName, portletName.substring(0, pos), portletsMap);
1052 }
1053
1054 private List<Portlet> _getPortletsByServletContextName(
1055 String servletContextName, String portletNamePrefix,
1056 Map<String, Portlet> portletsMap) {
1057
1058 List<Portlet> portlets = new ArrayList<>();
1059
1060 String servletContextNameSuffix = null;
1061
1062 if (Validator.isNotNull(servletContextName)) {
1063 servletContextNameSuffix = PortalUtil.getJsSafePortletId(
1064 PortletConstants.WAR_SEPARATOR.concat(servletContextName));
1065 }
1066
1067 for (Map.Entry<String, Portlet> entry : portletsMap.entrySet()) {
1068 String portletId = entry.getKey();
1069
1070 if (!portletId.startsWith(portletNamePrefix)) {
1071 continue;
1072 }
1073
1074 if (servletContextNameSuffix == null) {
1075 if (!portletId.contains(PortletConstants.WAR_SEPARATOR)) {
1076 portlets.add(entry.getValue());
1077 }
1078 }
1079 else if (portletId.endsWith(servletContextNameSuffix)) {
1080 portlets.add(entry.getValue());
1081 }
1082 }
1083
1084 return portlets;
1085 }
1086
1087 private Map<String, Portlet> _getPortletsMap(long companyId) {
1088 Map<String, Portlet> portletsMap = _portletsMaps.get(companyId);
1089
1090 if (portletsMap == null) {
1091 portletsMap = portletLocalService.loadGetPortletsMap(companyId);
1092
1093 _portletsMaps.put(companyId, portletsMap);
1094 }
1095
1096 return portletsMap;
1097 }
1098
1099 private String _getTriggerValue(Portlet portlet, String propertyKey) {
1100 PortletApp portletApp = portlet.getPortletApp();
1101
1102 ServletContext servletContext = portletApp.getServletContext();
1103
1104 ClassLoader classLoader = servletContext.getClassLoader();
1105
1106 Configuration configuration = _propertiesConfigurations.get(
1107 classLoader);
1108
1109 if (configuration == null) {
1110 String propertyFileName = "portal";
1111
1112 if (portletApp.isWARFile()) {
1113 propertyFileName = "portlet";
1114 }
1115
1116 configuration = ConfigurationFactoryUtil.getConfiguration(
1117 classLoader, propertyFileName);
1118
1119 _propertiesConfigurations.put(classLoader, configuration);
1120 }
1121
1122 return configuration.get(propertyKey);
1123 }
1124
1125 private void _readLiferayDisplay(
1126 String servletContextName, Element element,
1127 PortletCategory portletCategory, Set<String> portletIds) {
1128
1129 for (Element categoryElement : element.elements("category")) {
1130 String name = categoryElement.attributeValue("name");
1131
1132 PortletCategory curPortletCategory = new PortletCategory(name);
1133
1134 portletCategory.addCategory(curPortletCategory);
1135
1136 Set<String> curPortletIds = curPortletCategory.getPortletIds();
1137
1138 for (Element portletElement : categoryElement.elements("portlet")) {
1139 String portletId = portletElement.attributeValue("id");
1140
1141 if (Validator.isNotNull(servletContextName)) {
1142 portletId =
1143 portletId + PortletConstants.WAR_SEPARATOR +
1144 servletContextName;
1145 }
1146
1147 portletId = PortalUtil.getJsSafePortletId(portletId);
1148
1149 portletIds.add(portletId);
1150 curPortletIds.add(portletId);
1151 }
1152
1153 _readLiferayDisplay(
1154 servletContextName, categoryElement, curPortletCategory,
1155 portletIds);
1156 }
1157 }
1158
1159 private PortletCategory _readLiferayDisplayXML(String xml)
1160 throws Exception {
1161
1162 return _readLiferayDisplayXML(null, xml);
1163 }
1164
1165 private PortletCategory _readLiferayDisplayXML(
1166 String servletContextName, String xml)
1167 throws Exception {
1168
1169 PortletCategory portletCategory = new PortletCategory();
1170
1171 if (xml == null) {
1172 xml = ContentUtil.get(
1173 "com/liferay/portal/deploy/dependencies/liferay-display.xml");
1174 }
1175
1176 Document document = UnsecureSAXReaderUtil.read(xml, true);
1177
1178 Element rootElement = document.getRootElement();
1179
1180 Set<String> portletIds = new HashSet<>();
1181
1182 _readLiferayDisplay(
1183 servletContextName, rootElement, portletCategory, portletIds);
1184
1185
1186
1187
1188 Set<String> undefinedPortletIds = new HashSet<>();
1189
1190 for (Portlet portlet : _portletsMap.values()) {
1191 String portletId = portlet.getPortletId();
1192
1193 PortletApp portletApp = portlet.getPortletApp();
1194
1195 if ((servletContextName != null) && portletApp.isWARFile() &&
1196 portletId.endsWith(
1197 PortletConstants.WAR_SEPARATOR +
1198 PortalUtil.getJsSafePortletId(servletContextName)) &&
1199 !portletIds.contains(portletId)) {
1200
1201 undefinedPortletIds.add(portletId);
1202 }
1203 else if ((servletContextName == null) && !portletApp.isWARFile() &&
1204 !portletId.contains(PortletConstants.WAR_SEPARATOR) &&
1205 !portletIds.contains(portletId)) {
1206
1207 undefinedPortletIds.add(portletId);
1208 }
1209 }
1210
1211 if (!undefinedPortletIds.isEmpty()) {
1212 PortletCategory undefinedCategory = new PortletCategory(
1213 "category.undefined");
1214
1215 portletCategory.addCategory(undefinedCategory);
1216
1217 undefinedCategory.getPortletIds().addAll(undefinedPortletIds);
1218 }
1219
1220 return portletCategory;
1221 }
1222
1223 private void _readLiferayPortletXML(
1224 String servletContextName, ServletContext servletContext,
1225 Set<String> liferayPortletIds, Map<String, String> roleMappers,
1226 Element portletElement, Map<String, Portlet> portletsMap) {
1227
1228 String portletId = portletElement.elementText("portlet-name");
1229
1230 if (Validator.isNotNull(servletContextName)) {
1231 portletId = portletId.concat(PortletConstants.WAR_SEPARATOR).concat(
1232 servletContextName);
1233 }
1234
1235 portletId = PortalUtil.getJsSafePortletId(portletId);
1236
1237 if (_log.isDebugEnabled()) {
1238 _log.debug("Reading portlet extension " + portletId);
1239 }
1240
1241 liferayPortletIds.add(portletId);
1242
1243 Portlet portletModel = portletsMap.get(portletId);
1244
1245 if (portletModel == null) {
1246 return;
1247 }
1248
1249 portletModel.setIcon(
1250 GetterUtil.getString(
1251 portletElement.elementText("icon"), portletModel.getIcon()));
1252 portletModel.setVirtualPath(
1253 GetterUtil.getString(
1254 portletElement.elementText("virtual-path"),
1255 portletModel.getVirtualPath()));
1256 portletModel.setStrutsPath(
1257 GetterUtil.getString(
1258 portletElement.elementText("struts-path"),
1259 portletModel.getStrutsPath()));
1260
1261 String strutsPath = portletModel.getStrutsPath();
1262
1263 if (Validator.isNotNull(strutsPath)) {
1264 if (_portletIdsByStrutsPath.containsKey(strutsPath)) {
1265 String strutsPathPortletId = _portletIdsByStrutsPath.get(
1266 strutsPath);
1267
1268 if (!strutsPathPortletId.equals(portletId)) {
1269 if (_log.isWarnEnabled()) {
1270 _log.warn("Duplicate struts path " + strutsPath);
1271 }
1272 }
1273 }
1274
1275 _portletIdsByStrutsPath.put(strutsPath, portletId);
1276 }
1277
1278 portletModel.setParentStrutsPath(
1279 GetterUtil.getString(
1280 portletElement.elementText("parent-struts-path"),
1281 portletModel.getParentStrutsPath()));
1282
1283 if (Validator.isNotNull(
1284 portletElement.elementText("configuration-path"))) {
1285
1286 _log.error(
1287 "The configuration-path element is no longer supported. Use " +
1288 "configuration-action-class instead.");
1289 }
1290
1291 portletModel.setConfigurationActionClass(
1292 GetterUtil.getString(
1293 portletElement.elementText("configuration-action-class"),
1294 portletModel.getConfigurationActionClass()));
1295
1296 List<String> indexerClasses = new ArrayList<>();
1297
1298 for (Element indexerClassElement :
1299 portletElement.elements("indexer-class")) {
1300
1301 indexerClasses.add(indexerClassElement.getText());
1302 }
1303
1304 portletModel.setIndexerClasses(indexerClasses);
1305
1306 portletModel.setOpenSearchClass(
1307 GetterUtil.getString(
1308 portletElement.elementText("open-search-class"),
1309 portletModel.getOpenSearchClass()));
1310
1311 for (Element schedulerEntryElement :
1312 portletElement.elements("scheduler-entry")) {
1313
1314 SchedulerEntryImpl schedulerEntryImpl = new SchedulerEntryImpl();
1315
1316 String description = GetterUtil.getString(
1317 schedulerEntryElement.elementText("scheduler-description"));
1318
1319 schedulerEntryImpl.setDescription(description);
1320
1321 String eventListenerClass = GetterUtil.getString(
1322 schedulerEntryElement.elementText(
1323 "scheduler-event-listener-class"));
1324
1325 schedulerEntryImpl.setEventListenerClass(eventListenerClass);
1326
1327 Element triggerElement = schedulerEntryElement.element("trigger");
1328
1329 Element cronElement = triggerElement.element("cron");
1330 Element simpleElement = triggerElement.element("simple");
1331
1332 if (cronElement != null) {
1333 Element propertyKeyElement = cronElement.element(
1334 "property-key");
1335
1336 String cronException = null;
1337
1338 if (propertyKeyElement != null) {
1339 cronException = _getTriggerValue(
1340 portletModel, propertyKeyElement.getTextTrim());
1341 }
1342 else {
1343 cronException = cronElement.elementText(
1344 "cron-trigger-value");
1345 }
1346
1347 schedulerEntryImpl.setTrigger(
1348 TriggerFactoryUtil.createTrigger(
1349 eventListenerClass, eventListenerClass, cronException));
1350 }
1351 else if (simpleElement != null) {
1352 Element propertyKeyElement = simpleElement.element(
1353 "property-key");
1354
1355 String intervalString = null;
1356
1357 if (propertyKeyElement != null) {
1358 intervalString = _getTriggerValue(
1359 portletModel, propertyKeyElement.getTextTrim());
1360 }
1361 else {
1362 Element simpleTriggerValueElement = simpleElement.element(
1363 "simple-trigger-value");
1364
1365 intervalString = simpleTriggerValueElement.getTextTrim();
1366 }
1367
1368 String timeUnitString = StringUtil.toUpperCase(
1369 GetterUtil.getString(
1370 simpleElement.elementText("time-unit"),
1371 TimeUnit.SECOND.getValue()));
1372
1373 schedulerEntryImpl.setTrigger(
1374 TriggerFactoryUtil.createTrigger(
1375 eventListenerClass, eventListenerClass,
1376 GetterUtil.getIntegerStrict(intervalString),
1377 TimeUnit.valueOf(timeUnitString)));
1378 }
1379
1380 portletModel.addSchedulerEntry(schedulerEntryImpl);
1381 }
1382
1383 portletModel.setPortletURLClass(
1384 GetterUtil.getString(
1385 portletElement.elementText("portlet-url-class"),
1386 portletModel.getPortletURLClass()));
1387 portletModel.setFriendlyURLMapperClass(
1388 GetterUtil.getString(
1389 portletElement.elementText("friendly-url-mapper-class"),
1390 portletModel.getFriendlyURLMapperClass()));
1391 portletModel.setFriendlyURLMapping(
1392 GetterUtil.getString(
1393 portletElement.elementText("friendly-url-mapping"),
1394 portletModel.getFriendlyURLMapping()));
1395 portletModel.setFriendlyURLRoutes(
1396 GetterUtil.getString(
1397 portletElement.elementText("friendly-url-routes"),
1398 portletModel.getFriendlyURLRoutes()));
1399 portletModel.setURLEncoderClass(
1400 GetterUtil.getString(
1401 portletElement.elementText("url-encoder-class"),
1402 portletModel.getURLEncoderClass()));
1403 portletModel.setPortletDataHandlerClass(
1404 GetterUtil.getString(
1405 portletElement.elementText("portlet-data-handler-class"),
1406 portletModel.getPortletDataHandlerClass()));
1407
1408 List<String> stagedModelDataHandlerClasses = new ArrayList<>();
1409
1410 for (Element stagedModelDataHandlerClassElement :
1411 portletElement.elements("staged-model-data-handler-class")) {
1412
1413 stagedModelDataHandlerClasses.add(
1414 stagedModelDataHandlerClassElement.getText());
1415 }
1416
1417 portletModel.setStagedModelDataHandlerClasses(
1418 stagedModelDataHandlerClasses);
1419
1420 portletModel.setTemplateHandlerClass(
1421 GetterUtil.getString(
1422 portletElement.elementText("template-handler"),
1423 portletModel.getTemplateHandlerClass()));
1424 portletModel.setPortletLayoutListenerClass(
1425 GetterUtil.getString(
1426 portletElement.elementText("portlet-layout-listener-class"),
1427 portletModel.getPortletLayoutListenerClass()));
1428 portletModel.setPollerProcessorClass(
1429 GetterUtil.getString(
1430 portletElement.elementText("poller-processor-class"),
1431 portletModel.getPollerProcessorClass()));
1432 portletModel.setPopMessageListenerClass(
1433 GetterUtil.getString(
1434 portletElement.elementText("pop-message-listener-class"),
1435 portletModel.getPopMessageListenerClass()));
1436
1437 List<String> socialActivityInterpreterClasses = new ArrayList<>();
1438
1439 for (Element socialActivityInterpreterClassElement :
1440 portletElement.elements("social-activity-interpreter-class")) {
1441
1442 socialActivityInterpreterClasses.add(
1443 socialActivityInterpreterClassElement.getText());
1444 }
1445
1446 portletModel.setSocialActivityInterpreterClasses(
1447 socialActivityInterpreterClasses);
1448
1449 portletModel.setSocialRequestInterpreterClass(
1450 GetterUtil.getString(
1451 portletElement.elementText("social-request-interpreter-class"),
1452 portletModel.getSocialRequestInterpreterClass()));
1453 portletModel.setSocialInteractionsConfiguration(
1454 GetterUtil.getBoolean(
1455 portletElement.elementText("social-interactions-configuration"),
1456 portletModel.getSocialInteractionsConfiguration()));
1457 portletModel.setUserNotificationDefinitions(
1458 GetterUtil.getString(
1459 portletElement.elementText("user-notification-definitions"),
1460 portletModel.getUserNotificationDefinitions()));
1461
1462 List<String> userNotificationHandlerClasses = new ArrayList<>();
1463
1464 for (Element userNotificationHandlerClassElement :
1465 portletElement.elements(
1466 "user-notification-handler-class")) {
1467
1468 userNotificationHandlerClasses.add(
1469 userNotificationHandlerClassElement.getText());
1470 }
1471
1472 portletModel.setUserNotificationHandlerClasses(
1473 userNotificationHandlerClasses);
1474
1475 portletModel.setWebDAVStorageToken(
1476 GetterUtil.getString(
1477 portletElement.elementText("webdav-storage-token"),
1478 portletModel.getWebDAVStorageToken()));
1479 portletModel.setWebDAVStorageClass(
1480 GetterUtil.getString(
1481 portletElement.elementText("webdav-storage-class"),
1482 portletModel.getWebDAVStorageClass()));
1483 portletModel.setXmlRpcMethodClass(
1484 GetterUtil.getString(
1485 portletElement.elementText("xml-rpc-method-class"),
1486 portletModel.getXmlRpcMethodClass()));
1487
1488 Set<ApplicationType> applicationTypes = new HashSet<>();
1489
1490 for (Element applicationTypeElement :
1491 portletElement.elements("application-type")) {
1492
1493 try {
1494 applicationTypes.add(
1495 ApplicationType.parse(applicationTypeElement.getText()));
1496 }
1497 catch (IllegalArgumentException iae) {
1498 if (_log.isWarnEnabled()) {
1499 _log.warn(
1500 "Unknown application type " +
1501 applicationTypeElement.getText());
1502 }
1503 }
1504 }
1505
1506 if (applicationTypes.isEmpty()) {
1507 applicationTypes.add(ApplicationType.WIDGET);
1508 }
1509
1510 portletModel.setApplicationTypes(applicationTypes);
1511
1512 portletModel.setControlPanelEntryClass(
1513 GetterUtil.getString(
1514 portletElement.elementText("control-panel-entry-class"),
1515 portletModel.getControlPanelEntryClass()));
1516
1517 List<String> assetRendererFactoryClasses = new ArrayList<>();
1518
1519 for (Element assetRendererFactoryClassElement :
1520 portletElement.elements("asset-renderer-factory")) {
1521
1522 assetRendererFactoryClasses.add(
1523 assetRendererFactoryClassElement.getText());
1524 }
1525
1526 portletModel.setAssetRendererFactoryClasses(
1527 assetRendererFactoryClasses);
1528
1529 List<String> atomCollectionAdapterClasses = new ArrayList<>();
1530
1531 for (Element atomCollectionAdapterClassElement :
1532 portletElement.elements("atom-collection-adapter")) {
1533
1534 atomCollectionAdapterClasses.add(
1535 atomCollectionAdapterClassElement.getText());
1536 }
1537
1538 portletModel.setAtomCollectionAdapterClasses(
1539 atomCollectionAdapterClasses);
1540
1541 List<String> customAttributesDisplayClasses = new ArrayList<>();
1542
1543 for (Element customAttributesDisplayClassElement :
1544 portletElement.elements("custom-attributes-display")) {
1545
1546 customAttributesDisplayClasses.add(
1547 customAttributesDisplayClassElement.getText());
1548 }
1549
1550 portletModel.setCustomAttributesDisplayClasses(
1551 customAttributesDisplayClasses);
1552
1553 portletModel.setPermissionPropagatorClass(
1554 GetterUtil.getString(
1555 portletElement.elementText("permission-propagator"),
1556 portletModel.getPermissionPropagatorClass()));
1557
1558 List<String> trashHandlerClasses = new ArrayList<>();
1559
1560 for (Element trashHandlerClassElement :
1561 portletElement.elements("trash-handler")) {
1562
1563 trashHandlerClasses.add(trashHandlerClassElement.getText());
1564 }
1565
1566 portletModel.setTrashHandlerClasses(trashHandlerClasses);
1567
1568 List<String> workflowHandlerClasses = new ArrayList<>();
1569
1570 for (Element workflowHandlerClassElement :
1571 portletElement.elements("workflow-handler")) {
1572
1573 workflowHandlerClasses.add(workflowHandlerClassElement.getText());
1574 }
1575
1576 portletModel.setWorkflowHandlerClasses(workflowHandlerClasses);
1577
1578 portletModel.setPreferencesCompanyWide(
1579 GetterUtil.getBoolean(
1580 portletElement.elementText("preferences-company-wide"),
1581 portletModel.isPreferencesCompanyWide()));
1582 portletModel.setPreferencesUniquePerLayout(
1583 GetterUtil.getBoolean(
1584 portletElement.elementText("preferences-unique-per-layout"),
1585 portletModel.isPreferencesUniquePerLayout()));
1586 portletModel.setPreferencesOwnedByGroup(
1587 GetterUtil.getBoolean(
1588 portletElement.elementText("preferences-owned-by-group"),
1589 portletModel.isPreferencesOwnedByGroup()));
1590 portletModel.setUseDefaultTemplate(
1591 GetterUtil.getBoolean(
1592 portletElement.elementText("use-default-template"),
1593 portletModel.isUseDefaultTemplate()));
1594 portletModel.setShowPortletAccessDenied(
1595 GetterUtil.getBoolean(
1596 portletElement.elementText("show-portlet-access-denied"),
1597 portletModel.isShowPortletAccessDenied()));
1598 portletModel.setShowPortletInactive(
1599 GetterUtil.getBoolean(
1600 portletElement.elementText("show-portlet-inactive"),
1601 portletModel.isShowPortletInactive()));
1602 portletModel.setActionURLRedirect(
1603 GetterUtil.getBoolean(
1604 portletElement.elementText("action-url-redirect"),
1605 portletModel.isActionURLRedirect()));
1606 portletModel.setRestoreCurrentView(
1607 GetterUtil.getBoolean(
1608 portletElement.elementText("restore-current-view"),
1609 portletModel.isRestoreCurrentView()));
1610 portletModel.setMaximizeEdit(
1611 GetterUtil.getBoolean(
1612 portletElement.elementText("maximize-edit"),
1613 portletModel.isMaximizeEdit()));
1614 portletModel.setMaximizeHelp(
1615 GetterUtil.getBoolean(
1616 portletElement.elementText("maximize-help"),
1617 portletModel.isMaximizeHelp()));
1618 portletModel.setPopUpPrint(
1619 GetterUtil.getBoolean(
1620 portletElement.elementText("pop-up-print"),
1621 portletModel.isPopUpPrint()));
1622 portletModel.setLayoutCacheable(
1623 GetterUtil.getBoolean(
1624 portletElement.elementText("layout-cacheable"),
1625 portletModel.isLayoutCacheable()));
1626 portletModel.setInstanceable(
1627 GetterUtil.getBoolean(
1628 portletElement.elementText("instanceable"),
1629 portletModel.isInstanceable()));
1630 portletModel.setRemoteable(
1631 GetterUtil.getBoolean(
1632 portletElement.elementText("remoteable"),
1633 portletModel.isRemoteable()));
1634 portletModel.setScopeable(
1635 GetterUtil.getBoolean(
1636 portletElement.elementText("scopeable"),
1637 portletModel.isScopeable()));
1638 portletModel.setSinglePageApplication(
1639 GetterUtil.getBoolean(
1640 portletElement.elementText("single-page-application"),
1641 portletModel.isSinglePageApplication()));
1642 portletModel.setUserPrincipalStrategy(
1643 GetterUtil.getString(
1644 portletElement.elementText("user-principal-strategy"),
1645 portletModel.getUserPrincipalStrategy()));
1646 portletModel.setPrivateRequestAttributes(
1647 GetterUtil.getBoolean(
1648 portletElement.elementText("private-request-attributes"),
1649 portletModel.isPrivateRequestAttributes()));
1650 portletModel.setPrivateSessionAttributes(
1651 GetterUtil.getBoolean(
1652 portletElement.elementText("private-session-attributes"),
1653 portletModel.isPrivateSessionAttributes()));
1654
1655 Element autopropagatedParametersElement = portletElement.element(
1656 "autopropagated-parameters");
1657
1658 Set<String> autopropagatedParameters = new HashSet<>();
1659
1660 if (autopropagatedParametersElement != null) {
1661 String[] autopropagatedParametersArray = StringUtil.split(
1662 autopropagatedParametersElement.getText());
1663
1664 for (String autopropagatedParameter :
1665 autopropagatedParametersArray) {
1666
1667 autopropagatedParameters.add(autopropagatedParameter);
1668 }
1669 }
1670
1671 portletModel.setAutopropagatedParameters(autopropagatedParameters);
1672
1673 boolean defaultRequiresNamespacedParameters = GetterUtil.getBoolean(
1674 servletContext.getInitParameter(
1675 "com.liferay.portlet.requires-namespaced-parameters"),
1676 portletModel.isRequiresNamespacedParameters());
1677
1678 portletModel.setRequiresNamespacedParameters(
1679 GetterUtil.getBoolean(
1680 portletElement.elementText("requires-namespaced-parameters"),
1681 defaultRequiresNamespacedParameters));
1682
1683 portletModel.setActionTimeout(
1684 GetterUtil.getInteger(
1685 portletElement.elementText("action-timeout"),
1686 portletModel.getActionTimeout()));
1687 portletModel.setRenderTimeout(
1688 GetterUtil.getInteger(
1689 portletElement.elementText("render-timeout"),
1690 portletModel.getRenderTimeout()));
1691 portletModel.setRenderWeight(
1692 GetterUtil.getInteger(
1693 portletElement.elementText("render-weight"),
1694 portletModel.getRenderWeight()));
1695 portletModel.setAjaxable(
1696 GetterUtil.getBoolean(
1697 portletElement.elementText("ajaxable"),
1698 portletModel.isAjaxable()));
1699
1700 List<String> headerPortalCssList = new ArrayList<>();
1701
1702 for (Element headerPortalCssElement :
1703 portletElement.elements("header-portal-css")) {
1704
1705 headerPortalCssList.add(headerPortalCssElement.getText());
1706 }
1707
1708 portletModel.setHeaderPortalCss(headerPortalCssList);
1709
1710 List<String> headerPortletCssList = new ArrayList<>();
1711
1712 for (Element headerPortletCssElement :
1713 portletElement.elements("header-portlet-css")) {
1714
1715 headerPortletCssList.add(headerPortletCssElement.getText());
1716 }
1717
1718 portletModel.setHeaderPortletCss(headerPortletCssList);
1719
1720 List<String> headerPortalJavaScriptList = new ArrayList<>();
1721
1722 for (Element headerPortalJavaScriptElement :
1723 portletElement.elements("header-portal-javascript")) {
1724
1725 headerPortalJavaScriptList.add(
1726 headerPortalJavaScriptElement.getText());
1727 }
1728
1729 portletModel.setHeaderPortalJavaScript(headerPortalJavaScriptList);
1730
1731 List<String> headerPortletJavaScriptList = new ArrayList<>();
1732
1733 for (Element headerPortletJavaScriptElement :
1734 portletElement.elements("header-portlet-javascript")) {
1735
1736 headerPortletJavaScriptList.add(
1737 headerPortletJavaScriptElement.getText());
1738 }
1739
1740 portletModel.setHeaderPortletJavaScript(headerPortletJavaScriptList);
1741
1742 List<String> footerPortalCssList = new ArrayList<>();
1743
1744 for (Element footerPortalCssElement :
1745 portletElement.elements("footer-portal-css")) {
1746
1747 footerPortalCssList.add(footerPortalCssElement.getText());
1748 }
1749
1750 portletModel.setFooterPortalCss(footerPortalCssList);
1751
1752 List<String> footerPortletCssList = new ArrayList<>();
1753
1754 for (Element footerPortletCssElement :
1755 portletElement.elements("footer-portlet-css")) {
1756
1757 footerPortletCssList.add(footerPortletCssElement.getText());
1758 }
1759
1760 portletModel.setFooterPortletCss(footerPortletCssList);
1761
1762 List<String> footerPortalJavaScriptList = new ArrayList<>();
1763
1764 for (Element footerPortalJavaScriptElement :
1765 portletElement.elements("footer-portal-javascript")) {
1766
1767 footerPortalJavaScriptList.add(
1768 footerPortalJavaScriptElement.getText());
1769 }
1770
1771 portletModel.setFooterPortalJavaScript(footerPortalJavaScriptList);
1772
1773 List<String> footerPortletJavaScriptList = new ArrayList<>();
1774
1775 for (Element footerPortletJavaScriptElement :
1776 portletElement.elements("footer-portlet-javascript")) {
1777
1778 footerPortletJavaScriptList.add(
1779 footerPortletJavaScriptElement.getText());
1780 }
1781
1782 portletModel.setFooterPortletJavaScript(footerPortletJavaScriptList);
1783
1784 portletModel.setCssClassWrapper(
1785 GetterUtil.getString(
1786 portletElement.elementText("css-class-wrapper"),
1787 portletModel.getCssClassWrapper()));
1788 portletModel.setFacebookIntegration(
1789 GetterUtil.getString(
1790 portletElement.elementText("facebook-integration"),
1791 portletModel.getFacebookIntegration()));
1792 portletModel.setAddDefaultResource(
1793 GetterUtil.getBoolean(
1794 portletElement.elementText("add-default-resource"),
1795 portletModel.isAddDefaultResource()));
1796 portletModel.setSystem(
1797 GetterUtil.getBoolean(
1798 portletElement.elementText("system"), portletModel.isSystem()));
1799 portletModel.setActive(
1800 GetterUtil.getBoolean(
1801 portletElement.elementText("active"), portletModel.isActive()));
1802 portletModel.setInclude(
1803 GetterUtil.getBoolean(
1804 portletElement.elementText("include"),
1805 portletModel.isInclude()));
1806
1807 if (Validator.isNull(servletContextName)) {
1808 portletModel.setReady(true);
1809 }
1810
1811 if (!portletModel.isAjaxable() &&
1812 (portletModel.getRenderWeight() < 1)) {
1813
1814 portletModel.setRenderWeight(1);
1815 }
1816
1817 portletModel.getRoleMappers().putAll(roleMappers);
1818 portletModel.linkRoles();
1819 }
1820
1821 private Set<String> _readLiferayPortletXML(
1822 String servletContextName, ServletContext servletContext,
1823 String xml, Map<String, Portlet> portletsMap)
1824 throws Exception {
1825
1826 Set<String> liferayPortletIds = new HashSet<>();
1827
1828 if (xml == null) {
1829 return liferayPortletIds;
1830 }
1831
1832 Document document = UnsecureSAXReaderUtil.read(xml, true);
1833
1834 Element rootElement = document.getRootElement();
1835
1836 PortletApp portletApp = getPortletApp(servletContextName);
1837
1838 Map<String, String> roleMappers = new HashMap<>();
1839
1840 for (Element roleMapperElement : rootElement.elements("role-mapper")) {
1841 String roleName = roleMapperElement.elementText("role-name");
1842 String roleLink = roleMapperElement.elementText("role-link");
1843
1844 roleMappers.put(roleName, roleLink);
1845 }
1846
1847 Map<String, String> customUserAttributes =
1848 portletApp.getCustomUserAttributes();
1849
1850 for (Element customUserAttributeElement :
1851 rootElement.elements("custom-user-attribute")) {
1852
1853 String customClass = customUserAttributeElement.elementText(
1854 "custom-class");
1855
1856 for (Element nameElement :
1857 customUserAttributeElement.elements("name")) {
1858
1859 String name = nameElement.getText();
1860
1861 customUserAttributes.put(name, customClass);
1862 }
1863 }
1864
1865 for (Element portletElement : rootElement.elements("portlet")) {
1866 _readLiferayPortletXML(
1867 servletContextName, servletContext, liferayPortletIds,
1868 roleMappers, portletElement, portletsMap);
1869 }
1870
1871 return liferayPortletIds;
1872 }
1873
1874 private void _readPortletXML(
1875 String servletContextName, PluginPackage pluginPackage,
1876 PortletApp portletApp, Element portletElement,
1877 Map<String, Portlet> portletsMap)
1878 throws PortletIdException {
1879
1880 String portletName = portletElement.elementText("portlet-name");
1881
1882 String portletId = portletName;
1883
1884 if (Validator.isNotNull(servletContextName)) {
1885 portletId = portletId.concat(PortletConstants.WAR_SEPARATOR).concat(
1886 servletContextName);
1887 }
1888
1889 portletId = PortalUtil.getJsSafePortletId(portletId);
1890
1891 if (portletId.length() >
1892 PortletInstance.PORTLET_INSTANCE_KEY_MAX_LENGTH) {
1893
1894
1895
1896 throw new PortletIdException(
1897 "Portlet ID " + portletId + " has more than " +
1898 PortletInstance.PORTLET_INSTANCE_KEY_MAX_LENGTH +
1899 " characters");
1900 }
1901
1902 if (_log.isDebugEnabled()) {
1903 _log.debug("Reading portlet " + portletId);
1904 }
1905
1906 Portlet portletModel = _portletsMap.get(portletId);
1907
1908 if (portletModel == null) {
1909 portletModel = new PortletImpl(CompanyConstants.SYSTEM, portletId);
1910 }
1911
1912 portletModel.setPluginPackage(pluginPackage);
1913 portletModel.setPortletApp(portletApp);
1914
1915 portletModel.setPortletName(portletName);
1916 portletModel.setDisplayName(
1917 GetterUtil.getString(
1918 portletElement.elementText("display-name"),
1919 portletModel.getDisplayName()));
1920 portletModel.setPortletClass(
1921 GetterUtil.getString(portletElement.elementText("portlet-class")));
1922
1923 Map<String, String> initParams = new HashMap<>();
1924
1925 for (Element initParamElement : portletElement.elements("init-param")) {
1926 initParams.put(
1927 initParamElement.elementText("name"),
1928 initParamElement.elementText("value"));
1929 }
1930
1931 portletModel.setInitParams(initParams);
1932
1933 Element expirationCacheElement = portletElement.element(
1934 "expiration-cache");
1935
1936 if (expirationCacheElement != null) {
1937 portletModel.setExpCache(
1938 GetterUtil.getInteger(expirationCacheElement.getText()));
1939 }
1940
1941 Map<String, Set<String>> portletModes = new HashMap<>();
1942 Map<String, Set<String>> windowStates = new HashMap<>();
1943
1944 for (Element supportsElement : portletElement.elements("supports")) {
1945 String mimeType = supportsElement.elementText("mime-type");
1946
1947 Set<String> mimeTypePortletModes = new HashSet<>();
1948
1949 mimeTypePortletModes.add(
1950 StringUtil.toLowerCase(PortletMode.VIEW.toString()));
1951
1952 for (Element portletModeElement :
1953 supportsElement.elements("portlet-mode")) {
1954
1955 mimeTypePortletModes.add(
1956 StringUtil.toLowerCase(portletModeElement.getTextTrim()));
1957 }
1958
1959 portletModes.put(mimeType, mimeTypePortletModes);
1960
1961 Set<String> mimeTypeWindowStates = new HashSet<>();
1962
1963 mimeTypeWindowStates.add(
1964 StringUtil.toLowerCase(WindowState.NORMAL.toString()));
1965
1966 List<Element> windowStateElements = supportsElement.elements(
1967 "window-state");
1968
1969 if (windowStateElements.isEmpty()) {
1970 mimeTypeWindowStates.add(
1971 StringUtil.toLowerCase(WindowState.MAXIMIZED.toString()));
1972 mimeTypeWindowStates.add(
1973 StringUtil.toLowerCase(WindowState.MINIMIZED.toString()));
1974 mimeTypeWindowStates.add(
1975 StringUtil.toLowerCase(
1976 LiferayWindowState.EXCLUSIVE.toString()));
1977 mimeTypeWindowStates.add(
1978 StringUtil.toLowerCase(
1979 LiferayWindowState.POP_UP.toString()));
1980 }
1981
1982 for (Element windowStateElement : windowStateElements) {
1983 mimeTypeWindowStates.add(
1984 StringUtil.toLowerCase(windowStateElement.getTextTrim()));
1985 }
1986
1987 windowStates.put(mimeType, mimeTypeWindowStates);
1988 }
1989
1990 portletModel.setPortletModes(portletModes);
1991 portletModel.setWindowStates(windowStates);
1992
1993 Set<String> supportedLocales = new HashSet<>();
1994
1995
1996
1997
1998 for (Element supportedLocaleElement : portletElement.elements(
1999 "supported-locale")) {
2000
2001 String supportedLocale = supportedLocaleElement.getText();
2002
2003 supportedLocales.add(supportedLocale);
2004 }
2005
2006 portletModel.setSupportedLocales(supportedLocales);
2007
2008 portletModel.setResourceBundle(
2009 portletElement.elementText("resource-bundle"));
2010
2011 Element portletInfoElement = portletElement.element("portlet-info");
2012
2013 String portletInfoTitle = null;
2014 String portletInfoShortTitle = null;
2015 String portletInfoKeyWords = null;
2016 String portletInfoDescription = null;
2017
2018 if (portletInfoElement != null) {
2019 portletInfoTitle = portletInfoElement.elementText("title");
2020 portletInfoShortTitle = portletInfoElement.elementText(
2021 "short-title");
2022 portletInfoKeyWords = portletInfoElement.elementText("keywords");
2023 }
2024
2025 PortletInfo portletInfo = new PortletInfo(
2026 portletInfoTitle, portletInfoShortTitle, portletInfoKeyWords,
2027 portletInfoDescription);
2028
2029 portletModel.setPortletInfo(portletInfo);
2030
2031 Element portletPreferencesElement = portletElement.element(
2032 "portlet-preferences");
2033
2034 String defaultPreferences = null;
2035 String preferencesValidator = null;
2036
2037 if (portletPreferencesElement != null) {
2038 Element preferencesValidatorElement =
2039 portletPreferencesElement.element("preferences-validator");
2040
2041 if (preferencesValidatorElement != null) {
2042 preferencesValidator = preferencesValidatorElement.getText();
2043
2044 portletPreferencesElement.remove(preferencesValidatorElement);
2045 }
2046
2047 defaultPreferences = portletPreferencesElement.asXML();
2048 }
2049
2050 portletModel.setDefaultPreferences(defaultPreferences);
2051 portletModel.setPreferencesValidator(preferencesValidator);
2052
2053 if (!portletApp.isWARFile() &&
2054 Validator.isNotNull(preferencesValidator) &&
2055 PropsValues.PREFERENCE_VALIDATE_ON_STARTUP) {
2056
2057 try {
2058 PreferencesValidator preferencesValidatorObj =
2059 PortalUtil.getPreferencesValidator(portletModel);
2060
2061 preferencesValidatorObj.validate(
2062 PortletPreferencesFactoryUtil.fromDefaultXML(
2063 defaultPreferences));
2064 }
2065 catch (Exception e) {
2066 if (_log.isWarnEnabled()) {
2067 _log.warn(
2068 "Portlet with the name " + portletId +
2069 " does not have valid default preferences");
2070 }
2071 }
2072 }
2073
2074 Set<String> unlinkedRoles = new HashSet<>();
2075
2076 for (Element roleElement :
2077 portletElement.elements("security-role-ref")) {
2078
2079 unlinkedRoles.add(roleElement.elementText("role-name"));
2080 }
2081
2082 portletModel.setUnlinkedRoles(unlinkedRoles);
2083
2084 Set<QName> processingEvents = new HashSet<>();
2085
2086 for (Element supportedProcessingEventElement :
2087 portletElement.elements("supported-processing-event")) {
2088
2089 Element qNameElement = supportedProcessingEventElement.element(
2090 "qname");
2091 Element nameElement = supportedProcessingEventElement.element(
2092 "name");
2093
2094 QName qName = PortletQNameUtil.getQName(
2095 qNameElement, nameElement, portletApp.getDefaultNamespace());
2096
2097 processingEvents.add(qName);
2098
2099 Set<EventDefinition> eventDefinitions =
2100 portletApp.getEventDefinitions();
2101
2102 for (EventDefinition eventDefinition : eventDefinitions) {
2103 Set<QName> qNames = eventDefinition.getQNames();
2104
2105 if (qNames.contains(qName)) {
2106 processingEvents.addAll(qNames);
2107 }
2108 }
2109 }
2110
2111 portletModel.setProcessingEvents(processingEvents);
2112
2113 Set<QName> publishingEvents = new HashSet<>();
2114
2115 for (Element supportedPublishingEventElement :
2116 portletElement.elements("supported-publishing-event")) {
2117
2118 Element qNameElement = supportedPublishingEventElement.element(
2119 "qname");
2120 Element nameElement = supportedPublishingEventElement.element(
2121 "name");
2122
2123 QName qName = PortletQNameUtil.getQName(
2124 qNameElement, nameElement, portletApp.getDefaultNamespace());
2125
2126 publishingEvents.add(qName);
2127 }
2128
2129 portletModel.setPublishingEvents(publishingEvents);
2130
2131 Set<PublicRenderParameter> publicRenderParameters = new HashSet<>();
2132
2133 for (Element supportedPublicRenderParameter :
2134 portletElement.elements("supported-public-render-parameter")) {
2135
2136 String identifier = supportedPublicRenderParameter.getTextTrim();
2137
2138 PublicRenderParameter publicRenderParameter =
2139 portletApp.getPublicRenderParameter(identifier);
2140
2141 if (publicRenderParameter == null) {
2142 _log.error(
2143 "Supported public render parameter references " +
2144 "unknown identifier " + identifier);
2145
2146 continue;
2147 }
2148
2149 publicRenderParameters.add(publicRenderParameter);
2150 }
2151
2152 portletModel.setPublicRenderParameters(publicRenderParameters);
2153
2154 portletsMap.put(portletId, portletModel);
2155 }
2156
2157 private Map<String, Portlet> _readPortletXML(
2158 String servletContextName, ServletContext servletContext,
2159 String xml, Set<String> servletURLPatterns,
2160 PluginPackage pluginPackage)
2161 throws Exception {
2162
2163 Map<String, Portlet> portletsMap = new HashMap<>();
2164
2165 if (xml == null) {
2166 return portletsMap;
2167 }
2168
2169 Document document = UnsecureSAXReaderUtil.read(
2170 xml, PropsValues.PORTLET_XML_VALIDATE);
2171
2172 Element rootElement = document.getRootElement();
2173
2174 PortletApp portletApp = getPortletApp(servletContextName);
2175
2176 portletApp.addServletURLPatterns(servletURLPatterns);
2177 portletApp.setServletContext(servletContext);
2178
2179 Set<String> userAttributes = portletApp.getUserAttributes();
2180
2181 for (Element userAttributeElement :
2182 rootElement.elements("user-attribute")) {
2183
2184 String name = userAttributeElement.elementText("name");
2185
2186 userAttributes.add(name);
2187 }
2188
2189 String defaultNamespace = rootElement.elementText("default-namespace");
2190
2191 if (Validator.isNotNull(defaultNamespace)) {
2192 portletApp.setDefaultNamespace(defaultNamespace);
2193 }
2194
2195 for (Element eventDefinitionElement :
2196 rootElement.elements("event-definition")) {
2197
2198 Element qNameElement = eventDefinitionElement.element("qname");
2199 Element nameElement = eventDefinitionElement.element("name");
2200 String valueType = eventDefinitionElement.elementText("value-type");
2201
2202 QName qName = PortletQNameUtil.getQName(
2203 qNameElement, nameElement, portletApp.getDefaultNamespace());
2204
2205 EventDefinition eventDefinition = new EventDefinitionImpl(
2206 qName, valueType, portletApp);
2207
2208 List<Element> aliases = eventDefinitionElement.elements("alias");
2209
2210 for (Element alias : aliases) {
2211 qName = PortletQNameUtil.getQName(
2212 alias, null, portletApp.getDefaultNamespace());
2213
2214 eventDefinition.addAliasQName(qName);
2215 }
2216
2217 portletApp.addEventDefinition(eventDefinition);
2218 }
2219
2220 for (Element publicRenderParameterElement :
2221 rootElement.elements("public-render-parameter")) {
2222
2223 String identifier = publicRenderParameterElement.elementText(
2224 "identifier");
2225 Element qNameElement = publicRenderParameterElement.element(
2226 "qname");
2227 Element nameElement = publicRenderParameterElement.element("name");
2228
2229 QName qName = PortletQNameUtil.getQName(
2230 qNameElement, nameElement, portletApp.getDefaultNamespace());
2231
2232 PublicRenderParameter publicRenderParameter =
2233 new PublicRenderParameterImpl(identifier, qName, portletApp);
2234
2235 portletApp.addPublicRenderParameter(publicRenderParameter);
2236 }
2237
2238 for (Element containerRuntimeOptionElement :
2239 rootElement.elements("container-runtime-option")) {
2240
2241 String name = GetterUtil.getString(
2242 containerRuntimeOptionElement.elementText("name"));
2243
2244 List<String> values = new ArrayList<>();
2245
2246 for (Element valueElement :
2247 containerRuntimeOptionElement.elements("value")) {
2248
2249 values.add(valueElement.getTextTrim());
2250 }
2251
2252 Map<String, String[]> containerRuntimeOptions =
2253 portletApp.getContainerRuntimeOptions();
2254
2255 containerRuntimeOptions.put(
2256 name, values.toArray(new String[values.size()]));
2257
2258 if (name.equals(
2259 LiferayPortletConfig.RUNTIME_OPTION_PORTAL_CONTEXT) &&
2260 !values.isEmpty() && GetterUtil.getBoolean(values.get(0))) {
2261
2262 portletApp.setWARFile(false);
2263 }
2264 }
2265
2266 for (Element portletElement : rootElement.elements("portlet")) {
2267 _readPortletXML(
2268 servletContextName, pluginPackage, portletApp, portletElement,
2269 portletsMap);
2270 }
2271
2272 for (Element filterElement : rootElement.elements("filter")) {
2273 String filterName = filterElement.elementText("filter-name");
2274 String filterClass = filterElement.elementText("filter-class");
2275
2276 Set<String> lifecycles = new LinkedHashSet<>();
2277
2278 for (Element lifecycleElement :
2279 filterElement.elements("lifecycle")) {
2280
2281 lifecycles.add(lifecycleElement.getText());
2282 }
2283
2284 Map<String, String> initParams = new HashMap<>();
2285
2286 for (Element initParamElement :
2287 filterElement.elements("init-param")) {
2288
2289 initParams.put(
2290 initParamElement.elementText("name"),
2291 initParamElement.elementText("value"));
2292 }
2293
2294 PortletFilter portletFilter = new PortletFilterImpl(
2295 filterName, filterClass, lifecycles, initParams, portletApp);
2296
2297 portletApp.addPortletFilter(portletFilter);
2298 }
2299
2300 for (Element filterMappingElement :
2301 rootElement.elements("filter-mapping")) {
2302
2303 String filterName = filterMappingElement.elementText("filter-name");
2304
2305 PortletFilter portletFilter = portletApp.getPortletFilter(
2306 filterName);
2307
2308 if (portletFilter == null) {
2309 _log.error(
2310 "Filter mapping references unknown filter name " +
2311 filterName);
2312
2313 continue;
2314 }
2315
2316 for (Element portletNameElement :
2317 filterMappingElement.elements("portlet-name")) {
2318
2319 String portletName = portletNameElement.getTextTrim();
2320
2321 List<Portlet> portletModels = _getPortletsByPortletName(
2322 portletName, servletContextName, portletsMap);
2323
2324 if (portletModels.isEmpty()) {
2325 _log.error(
2326 "Filter mapping with filter name " + filterName +
2327 " references unknown portlet name " + portletName);
2328 }
2329
2330 for (Portlet portletModel : portletModels) {
2331 portletModel.getPortletFilters().put(
2332 filterName, portletFilter);
2333 }
2334 }
2335 }
2336
2337 for (Element listenerElement : rootElement.elements("listener")) {
2338 String listenerClass = listenerElement.elementText(
2339 "listener-class");
2340
2341 PortletURLListener portletURLListener = new PortletURLListenerImpl(
2342 listenerClass, portletApp);
2343
2344 portletApp.addPortletURLListener(portletURLListener);
2345 }
2346
2347 return portletsMap;
2348 }
2349
2350 private Set<String> _readWebXML(String xml) throws Exception {
2351 Set<String> servletURLPatterns = new LinkedHashSet<>();
2352
2353 if (xml == null) {
2354 return servletURLPatterns;
2355 }
2356
2357 Document document = UnsecureSAXReaderUtil.read(xml);
2358
2359 Element rootElement = document.getRootElement();
2360
2361 for (Element servletMappingElement :
2362 rootElement.elements("servlet-mapping")) {
2363
2364 String urlPattern = servletMappingElement.elementText(
2365 "url-pattern");
2366
2367 servletURLPatterns.add(urlPattern);
2368 }
2369
2370 return servletURLPatterns;
2371 }
2372
2373 private void _setSpriteImages(
2374 ServletContext servletContext, PortletApp portletApp,
2375 String resourcePath)
2376 throws Exception {
2377
2378 Set<String> resourcePaths = servletContext.getResourcePaths(
2379 resourcePath);
2380
2381 if ((resourcePaths == null) || resourcePaths.isEmpty()) {
2382 return;
2383 }
2384
2385 List<URL> imageURLs = new ArrayList<>(resourcePaths.size());
2386
2387 for (String curResourcePath : resourcePaths) {
2388 if (curResourcePath.endsWith(StringPool.SLASH)) {
2389 _setSpriteImages(servletContext, portletApp, curResourcePath);
2390 }
2391 else if (curResourcePath.endsWith(".png")) {
2392 URL imageURL = servletContext.getResource(curResourcePath);
2393
2394 if (imageURL != null) {
2395 imageURLs.add(imageURL);
2396 }
2397 else {
2398 _log.error(
2399 "Resource URL for " + curResourcePath + " is null");
2400 }
2401 }
2402 }
2403
2404 String spriteRootDirName = PropsValues.SPRITE_ROOT_DIR;
2405 String spriteFileName = resourcePath.concat(
2406 PropsValues.SPRITE_FILE_NAME);
2407 String spritePropertiesFileName = resourcePath.concat(
2408 PropsValues.SPRITE_PROPERTIES_FILE_NAME);
2409 String rootPath = ServletContextUtil.getRootPath(servletContext);
2410
2411 Properties spriteProperties = SpriteProcessorUtil.generate(
2412 servletContext, imageURLs, spriteRootDirName, spriteFileName,
2413 spritePropertiesFileName, rootPath, 16, 16, 10240);
2414
2415 if (spriteProperties == null) {
2416 return;
2417 }
2418
2419 String contextPath = servletContext.getContextPath();
2420
2421 spriteFileName = contextPath.concat(SpriteProcessor.PATH).concat(
2422 spriteFileName);
2423
2424 portletApp.setSpriteImages(spriteFileName, spriteProperties);
2425 }
2426
2427 private static final Log _log = LogFactoryUtil.getLog(
2428 PortletLocalServiceImpl.class);
2429
2430 private static final Map<String, PortletApp> _portletApps =
2431 new ConcurrentHashMap<>();
2432 private static final Map<String, String> _portletIdsByStrutsPath =
2433 new ConcurrentHashMap<>();
2434 private static final Map<String, Portlet> _portletsMap =
2435 new ConcurrentHashMap<>();
2436 private static final Map<Long, Map<String, Portlet>> _portletsMaps =
2437 new ConcurrentHashMap<>();
2438 private static final Map<ClassLoader, Configuration>
2439 _propertiesConfigurations = new ConcurrentHashMap<>();
2440
2441 }