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