1
22
23 package com.liferay.portal.service.impl;
24
25 import com.liferay.portal.SystemException;
26 import com.liferay.portal.kernel.image.SpriteProcessorUtil;
27 import com.liferay.portal.kernel.log.Log;
28 import com.liferay.portal.kernel.log.LogFactoryUtil;
29 import com.liferay.portal.kernel.plugin.PluginPackage;
30 import com.liferay.portal.kernel.portlet.FriendlyURLMapper;
31 import com.liferay.portal.kernel.portlet.LiferayWindowState;
32 import com.liferay.portal.kernel.servlet.ServletContextUtil;
33 import com.liferay.portal.kernel.util.GetterUtil;
34 import com.liferay.portal.kernel.util.ListUtil;
35 import com.liferay.portal.kernel.util.ServerDetector;
36 import com.liferay.portal.kernel.util.StringPool;
37 import com.liferay.portal.kernel.util.Validator;
38 import com.liferay.portal.kernel.xml.Document;
39 import com.liferay.portal.kernel.xml.Element;
40 import com.liferay.portal.kernel.xml.SAXReaderUtil;
41 import com.liferay.portal.model.CompanyConstants;
42 import com.liferay.portal.model.EventDefinition;
43 import com.liferay.portal.model.Portlet;
44 import com.liferay.portal.model.PortletApp;
45 import com.liferay.portal.model.PortletCategory;
46 import com.liferay.portal.model.PortletConstants;
47 import com.liferay.portal.model.PortletFilter;
48 import com.liferay.portal.model.PortletInfo;
49 import com.liferay.portal.model.PortletURLListener;
50 import com.liferay.portal.model.PublicRenderParameter;
51 import com.liferay.portal.model.impl.EventDefinitionImpl;
52 import com.liferay.portal.model.impl.PortletAppImpl;
53 import com.liferay.portal.model.impl.PortletFilterImpl;
54 import com.liferay.portal.model.impl.PortletImpl;
55 import com.liferay.portal.model.impl.PortletURLListenerImpl;
56 import com.liferay.portal.model.impl.PublicRenderParameterImpl;
57 import com.liferay.portal.security.permission.ResourceActionsUtil;
58 import com.liferay.portal.service.base.PortletLocalServiceBaseImpl;
59 import com.liferay.portal.util.ContentUtil;
60 import com.liferay.portal.util.PortalUtil;
61 import com.liferay.portal.util.PortletKeys;
62 import com.liferay.portal.util.PropsValues;
63 import com.liferay.portal.util.QNameUtil;
64 import com.liferay.portal.util.WebAppPool;
65 import com.liferay.portal.util.WebKeys;
66 import com.liferay.portlet.PortletConfigImpl;
67 import com.liferay.portlet.PortletPreferencesSerializer;
68
69 import java.io.File;
70
71 import java.util.ArrayList;
72 import java.util.HashMap;
73 import java.util.HashSet;
74 import java.util.Iterator;
75 import java.util.LinkedHashSet;
76 import java.util.List;
77 import java.util.Map;
78 import java.util.Properties;
79 import java.util.Set;
80 import java.util.concurrent.ConcurrentHashMap;
81
82 import javax.portlet.PortletMode;
83 import javax.portlet.PreferencesValidator;
84 import javax.portlet.WindowState;
85
86 import javax.servlet.ServletContext;
87
88 import javax.xml.namespace.QName;
89
90
97 public class PortletLocalServiceImpl extends PortletLocalServiceBaseImpl {
98
99 public Portlet deployRemotePortlet(Portlet portlet)
100 throws SystemException {
101
102 Map<String, Portlet> portletsPool = _getPortletsPool();
103
104 portletsPool.put(portlet.getPortletId(), portlet);
105
106 _clearCaches();
107
108 PortletCategory newPortletCategory = new PortletCategory();
109
110 PortletCategory wsrpCategory = new PortletCategory(_WSRP_CATEGORY);
111
112 newPortletCategory.addCategory(wsrpCategory);
113
114 wsrpCategory.getPortletIds().add(portlet.getPortletId());
115
116 long companyId = portlet.getCompanyId();
117
118 PortletCategory portletCategory = (PortletCategory)WebAppPool.get(
119 String.valueOf(companyId), WebKeys.PORTLET_CATEGORY);
120
121 if (portletCategory != null) {
122 portletCategory.merge(newPortletCategory);
123 }
124 else {
125 _log.error(
126 "Unable to register remote portlet for company " + companyId +
127 " because it does not exist");
128 }
129
130 List<String> portletActions =
131 ResourceActionsUtil.getPortletResourceActions(
132 portlet.getPortletId());
133
134 resourceActionLocalService.checkResourceActions(
135 portlet.getPortletId(), portletActions);
136
137 return portlet;
138 }
139
140 public void destroyRemotePortlet(Portlet portlet) {
141 Map<String, Portlet> portletsPool = _getPortletsPool();
142
143 portletsPool.remove(portlet.getRootPortletId());
144
145 PortletApp portletApp = portlet.getPortletApp();
146
147 _portletAppsPool.remove(portletApp.getServletContextName());
148
149 _clearCaches();
150 }
151
152 public void destroyPortlet(Portlet portlet) {
153 Map<String, Portlet> portletsPool = _getPortletsPool();
154
155 portletsPool.remove(portlet.getRootPortletId());
156
157 PortletApp portletApp = portlet.getPortletApp();
158
159 if (portletApp != null) {
160 _portletAppsPool.remove(portletApp.getServletContextName());
161 }
162
163 _clearCaches();
164 }
165
166 public PortletCategory getEARDisplay(String xml) throws SystemException {
167 try {
168 return _readLiferayDisplayXML(xml);
169 }
170 catch (Exception e) {
171 throw new SystemException(e);
172 }
173 }
174
175 public PortletApp getPortletApp(String servletContextName) {
176 return _getPortletApp(servletContextName);
177 }
178
179 public PortletCategory getWARDisplay(String servletContextName, String xml)
180 throws SystemException {
181
182 try {
183 return _readLiferayDisplayXML(servletContextName, xml);
184 }
185 catch (Exception e) {
186 throw new SystemException(e);
187 }
188 }
189
190 public List<Portlet> getFriendlyURLMapperPortlets() {
191 List<Portlet> portlets = new ArrayList<Portlet>(
192 _friendlyURLMapperPortlets.size());
193
194 Iterator<Map.Entry<String, Portlet>> itr =
195 _friendlyURLMapperPortlets.entrySet().iterator();
196
197 while (itr.hasNext()) {
198 Map.Entry<String, Portlet> entry = itr.next();
199
200 Portlet portlet = entry.getValue();
201
202 FriendlyURLMapper friendlyURLMapper =
203 portlet.getFriendlyURLMapperInstance();
204
205 if (friendlyURLMapper != null) {
206 portlets.add(portlet);
207 }
208 }
209
210 return portlets;
211 }
212
213 public List<FriendlyURLMapper> getFriendlyURLMappers() {
214 List<FriendlyURLMapper> friendlyURLMappers =
215 new ArrayList<FriendlyURLMapper>(_friendlyURLMapperPortlets.size());
216
217 Iterator<Map.Entry<String, Portlet>> itr =
218 _friendlyURLMapperPortlets.entrySet().iterator();
219
220 while (itr.hasNext()) {
221 Map.Entry<String, Portlet> entry = itr.next();
222
223 Portlet portlet = entry.getValue();
224
225 FriendlyURLMapper friendlyURLMapper =
226 portlet.getFriendlyURLMapperInstance();
227
228 if (friendlyURLMapper != null) {
229 friendlyURLMappers.add(friendlyURLMapper);
230 }
231 }
232
233 return friendlyURLMappers;
234 }
235
236 public Portlet getPortletById(String portletId) {
237 Map<String, Portlet> portletsPool = _getPortletsPool();
238
239 return portletsPool.get(portletId);
240 }
241
242 public Portlet getPortletById(long companyId, String portletId)
243 throws SystemException {
244
245 portletId = PortalUtil.getJsSafePortletId(portletId);
246
247 Portlet portlet = null;
248
249 Map<String, Portlet> companyPortletsPool = _getPortletsPool(companyId);
250
251 String rootPortletId = PortletConstants.getRootPortletId(portletId);
252
253 if (portletId.equals(rootPortletId)) {
254 portlet = companyPortletsPool.get(portletId);
255 }
256 else {
257 portlet = companyPortletsPool.get(rootPortletId);
258
259 if (portlet != null) {
260 portlet = portlet.getClonedInstance(portletId);
261 }
262 }
263
264 if ((portlet == null) &&
265 (!portletId.equals(PortletKeys.LIFERAY_PORTAL))) {
266
267 if (_portletsPool.isEmpty()) {
268 if (_log.isDebugEnabled()) {
269 _log.debug("No portlets are installed");
270 }
271 }
272 else {
273 if (_log.isWarnEnabled()) {
274 _log.warn(
275 "Portlet not found for " + companyId + " " + portletId);
276 }
277 }
278 }
279
280 return portlet;
281 }
282
283 public Portlet getPortletByStrutsPath(long companyId, String strutsPath)
284 throws SystemException {
285
286 return getPortletById(companyId, _getPortletId(strutsPath));
287 }
288
289 public List<Portlet> getPortlets() {
290 Map<String, Portlet> portletsPool = _getPortletsPool();
291
292 return ListUtil.fromCollection(portletsPool.values());
293 }
294
295 public List<Portlet> getPortlets(long companyId) throws SystemException {
296 return getPortlets(companyId, true, true);
297 }
298
299 public List<Portlet> getPortlets(
300 long companyId, boolean showSystem, boolean showPortal)
301 throws SystemException {
302
303 Map<String, Portlet> portletsPool = _getPortletsPool(companyId);
304
305 List<Portlet> portlets = ListUtil.fromCollection(portletsPool.values());
306
307 if (!showSystem || !showPortal) {
308 Iterator<Portlet> itr = portlets.iterator();
309
310 while (itr.hasNext()) {
311 Portlet portlet = itr.next();
312
313 if (showPortal &&
314 portlet.getPortletId().equals(PortletKeys.PORTAL)) {
315
316 }
317 else if (!showPortal &&
318 portlet.getPortletId().equals(PortletKeys.PORTAL)) {
319
320 itr.remove();
321 }
322 else if (!showSystem && portlet.isSystem()) {
323 itr.remove();
324 }
325 }
326 }
327
328 return portlets;
329 }
330
331 public boolean hasPortlet(long companyId, String portletId)
332 throws SystemException {
333
334 portletId = PortalUtil.getJsSafePortletId(portletId);
335
336 Portlet portlet = null;
337
338 Map<String, Portlet> companyPortletsPool = _getPortletsPool(companyId);
339
340 String rootPortletId = PortletConstants.getRootPortletId(portletId);
341
342 if (portletId.equals(rootPortletId)) {
343 portlet = companyPortletsPool.get(portletId);
344 }
345 else {
346 portlet = companyPortletsPool.get(rootPortletId);
347 }
348
349 if (portlet == null) {
350 return false;
351 }
352 else {
353 return true;
354 }
355 }
356
357 public void initEAR(
358 ServletContext servletContext, String[] xmls,
359 PluginPackage pluginPackage) {
360
361
363 _portletAppsPool.clear();
364 _portletsPool.clear();
365 _companyPortletsPool.clear();
366 _portletIdsByStrutsPath.clear();
367 _friendlyURLMapperPortlets.clear();
368
369 Map<String, Portlet> portletsPool = _getPortletsPool();
370
371 try {
372 List<String> servletURLPatterns = _readWebXML(xmls[4]);
373
374 Set<String> portletIds = _readPortletXML(
375 servletContext, xmls[0], portletsPool, servletURLPatterns,
376 pluginPackage);
377
378 portletIds.addAll(
379 _readPortletXML(
380 servletContext, xmls[1], portletsPool, servletURLPatterns,
381 pluginPackage));
382
383 Set<String> liferayPortletIds =
384 _readLiferayPortletXML(xmls[2], portletsPool);
385
386 liferayPortletIds.addAll(
387 _readLiferayPortletXML(xmls[3], portletsPool));
388
389
391 Iterator<String> portletIdsItr = portletIds.iterator();
392
393 while (portletIdsItr.hasNext()) {
394 String portletId = portletIdsItr.next();
395
396 if (_log.isWarnEnabled() &&
397 !liferayPortletIds.contains(portletId)) {
398
399 _log.warn(
400 "Portlet with the name " + portletId +
401 " is described in portlet.xml but does not " +
402 "have a matching entry in liferay-portlet.xml");
403 }
404 }
405
406
408 Iterator<String> liferayPortletIdsItr =
409 liferayPortletIds.iterator();
410
411 while (liferayPortletIdsItr.hasNext()) {
412 String portletId = liferayPortletIdsItr.next();
413
414 if (_log.isWarnEnabled() && !portletIds.contains(portletId)) {
415 _log.warn(
416 "Portlet with the name " + portletId +
417 " is described in liferay-portlet.xml but does " +
418 "not have a matching entry in portlet.xml");
419 }
420 }
421
422
424 Iterator<Map.Entry<String, Portlet>> portletPoolsItr =
425 portletsPool.entrySet().iterator();
426
427 while (portletPoolsItr.hasNext()) {
428 Map.Entry<String, Portlet> entry = portletPoolsItr.next();
429
430 Portlet portletModel = entry.getValue();
431
432 if (!portletModel.getPortletId().equals(PortletKeys.ADMIN) &&
433 !portletModel.getPortletId().equals(
434 PortletKeys.MY_ACCOUNT) &&
435 !portletModel.isInclude()) {
436
437 portletPoolsItr.remove();
438 }
439 }
440
441
443 PortletApp portletApp = _getPortletApp(StringPool.BLANK);
444
445 _setSpriteImages(servletContext, portletApp, "/html/icons/");
446 }
447 catch (Exception e) {
448 _log.error(e, e);
449 }
450 }
451
452 public List<Portlet> initWAR(
453 String servletContextName, ServletContext servletContext, String[] xmls,
454 PluginPackage pluginPackage) {
455
456 List<Portlet> portlets = new ArrayList<Portlet>();
457
458 Map<String, Portlet> portletsPool = _getPortletsPool();
459
460 try {
461 List<String> servletURLPatterns = _readWebXML(xmls[3]);
462
463 Set<String> portletIds = _readPortletXML(
464 servletContextName, servletContext, xmls[0], portletsPool,
465 servletURLPatterns, pluginPackage);
466
467 portletIds.addAll(
468 _readPortletXML(
469 servletContextName, servletContext, xmls[1], portletsPool,
470 servletURLPatterns, pluginPackage));
471
472 Set<String> liferayPortletIds = _readLiferayPortletXML(
473 servletContextName, xmls[2], portletsPool);
474
475
477 Iterator<String> itr = portletIds.iterator();
478
479 while (itr.hasNext()) {
480 String portletId = itr.next();
481
482 if (_log.isWarnEnabled() &&
483 !liferayPortletIds.contains(portletId)) {
484
485 _log.warn(
486 "Portlet with the name " + portletId +
487 " is described in portlet.xml but does not " +
488 "have a matching entry in liferay-portlet.xml");
489 }
490 }
491
492
494 itr = liferayPortletIds.iterator();
495
496 while (itr.hasNext()) {
497 String portletId = itr.next();
498
499 if (_log.isWarnEnabled() && !portletIds.contains(portletId)) {
500 _log.warn(
501 "Portlet with the name " + portletId +
502 " is described in liferay-portlet.xml but does " +
503 "not have a matching entry in portlet.xml");
504 }
505 }
506
507
509 itr = portletIds.iterator();
510
511 while (itr.hasNext()) {
512 String portletId = itr.next();
513
514 Portlet portlet = _getPortletsPool().get(portletId);
515
516 portlets.add(portlet);
517 }
518
519
521 PortletApp portletApp = _getPortletApp(servletContextName);
522
523 _setSpriteImages(servletContext, portletApp, "/icons/");
524 }
525 catch (Exception e) {
526 _log.error(e, e);
527 }
528
529 _clearCaches();
530
531 return portlets;
532 }
533
534 public Portlet updatePortlet(
535 long companyId, String portletId, String roles, boolean active)
536 throws SystemException {
537
538 portletId = PortalUtil.getJsSafePortletId(portletId);
539
540 Portlet portlet = portletPersistence.fetchByC_P(companyId, portletId);
541
542 if (portlet == null) {
543 long id = counterLocalService.increment();
544
545 portlet = portletPersistence.create(id);
546
547 portlet.setCompanyId(companyId);
548 portlet.setPortletId(portletId);
549 }
550
551 portlet.setRoles(roles);
552 portlet.setActive(active);
553
554 portletPersistence.update(portlet, false);
555
556 portlet = getPortletById(companyId, portletId);
557
558 portlet.setRoles(roles);
559 portlet.setActive(active);
560
561 return portlet;
562 }
563
564 private void _clearCaches() {
565
566
568 _portletIdsByStrutsPath.clear();
569
570
572 _companyPortletsPool.clear();
573 }
574
575 private PortletApp _getPortletApp(String servletContextName) {
576 PortletApp portletApp = _portletAppsPool.get(servletContextName);
577
578 if (portletApp == null) {
579 portletApp = new PortletAppImpl(servletContextName);
580
581 _portletAppsPool.put(servletContextName, portletApp);
582 }
583
584 return portletApp;
585 }
586
587 private String _getPortletId(String securityPath) {
588 if (_portletIdsByStrutsPath.size() == 0) {
589 Iterator<Portlet> itr = _getPortletsPool().values().iterator();
590
591 while (itr.hasNext()) {
592 Portlet portlet = itr.next();
593
594 _portletIdsByStrutsPath.put(
595 portlet.getStrutsPath(), portlet.getPortletId());
596 }
597 }
598
599 String portletId = _portletIdsByStrutsPath.get(securityPath);
600
601 if (Validator.isNull(portletId)) {
602 _log.error(
603 "Struts path " + securityPath + " is not mapped to a portlet " +
604 "in liferay-portlet.xml");
605 }
606
607 return portletId;
608 }
609
610 private List<Portlet> _getPortletsByPortletName(
611 String portletName, String servletContextName,
612 Map<String, Portlet> portletsPool) {
613
614 List<Portlet> portlets = null;
615
616 int pos = portletName.indexOf(StringPool.STAR);
617
618 if (pos == -1) {
619 portlets = new ArrayList<Portlet>();
620
621 String portletId = portletName;
622
623 if (Validator.isNotNull(servletContextName)) {
624 portletId =
625 portletId + PortletConstants.WAR_SEPARATOR +
626 servletContextName;
627 }
628
629 portletId = PortalUtil.getJsSafePortletId(portletId);
630
631 Portlet portlet = portletsPool.get(portletId);
632
633 if (portlet != null) {
634 portlets.add(portlet);
635 }
636
637 return portlets;
638 }
639
640 String portletNamePrefix = portletName.substring(0, pos);
641
642 portlets = _getPortletsByServletContextName(
643 servletContextName, portletsPool);
644
645 Iterator<Portlet> itr = portlets.iterator();
646
647 while (itr.hasNext()) {
648 Portlet portlet = itr.next();
649
650 if (!portlet.getPortletId().startsWith(portletNamePrefix)) {
651 itr.remove();
652 }
653 }
654
655 return portlets;
656 }
657
658 private List<Portlet> _getPortletsByServletContextName(
659 String servletContextName, Map<String, Portlet> portletsPool) {
660
661 List<Portlet> portlets = new ArrayList<Portlet>();
662
663 Iterator<Map.Entry<String, Portlet>> itr =
664 portletsPool.entrySet().iterator();
665
666 while (itr.hasNext()) {
667 Map.Entry<String, Portlet> entry = itr.next();
668
669 String portletId = entry.getKey();
670 Portlet portlet = entry.getValue();
671
672 if (Validator.isNotNull(servletContextName)) {
673 if (portletId.endsWith(
674 PortletConstants.WAR_SEPARATOR + servletContextName)) {
675
676 portlets.add(portlet);
677 }
678 }
679 else {
680 if (portletId.indexOf(PortletConstants.WAR_SEPARATOR) == -1) {
681 portlets.add(portlet);
682 }
683 }
684 }
685
686 return portlets;
687 }
688
689 private Map<String, Portlet> _getPortletsPool() {
690 return _portletsPool;
691 }
692
693 private Map<String, Portlet> _getPortletsPool(long companyId)
694 throws SystemException {
695
696 Map<String, Portlet> portletsPool = _companyPortletsPool.get(companyId);
697
698 if (portletsPool == null) {
699 portletsPool = new ConcurrentHashMap<String, Portlet>();
700
701 Map<String, Portlet> parentPortletsPool = _getPortletsPool();
702
703 if (parentPortletsPool == null) {
704
705
709 return portletsPool;
710 }
711
712 Iterator<Portlet> itr = parentPortletsPool.values().iterator();
713
714 while (itr.hasNext()) {
715 Portlet portlet = itr.next();
716
717 portlet = (Portlet)portlet.clone();
718
719 portlet.setCompanyId(companyId);
720
721 portletsPool.put(portlet.getPortletId(), portlet);
722 }
723
724 itr = portletPersistence.findByCompanyId(companyId).iterator();
725
726 while (itr.hasNext()) {
727 Portlet portlet = itr.next();
728
729 Portlet portletModel = portletsPool.get(portlet.getPortletId());
730
731
734 if (portletModel != null) {
735 portletModel.setPluginPackage(portlet.getPluginPackage());
736 portletModel.setDefaultPluginSetting(
737 portlet.getDefaultPluginSetting());
738 portletModel.setRoles(portlet.getRoles());
739 portletModel.setActive(portlet.getActive());
740 }
741 }
742
743 _companyPortletsPool.put(companyId, portletsPool);
744 }
745
746 return portletsPool;
747 }
748
749 private void _readLiferayDisplay(
750 String servletContextName, Element el, PortletCategory portletCategory,
751 Set<String> portletIds) {
752
753 Iterator<Element> itr1 = el.elements("category").iterator();
754
755 while (itr1.hasNext()) {
756 Element category = itr1.next();
757
758 String name = category.attributeValue("name");
759
760 PortletCategory curPortletCategory = new PortletCategory(name);
761
762 portletCategory.addCategory(curPortletCategory);
763
764 Set<String> curPortletIds = curPortletCategory.getPortletIds();
765
766 Iterator<Element> itr2 = category.elements("portlet").iterator();
767
768 while (itr2.hasNext()) {
769 Element portlet = itr2.next();
770
771 String portletId = portlet.attributeValue("id");
772
773 if (Validator.isNotNull(servletContextName)) {
774 portletId =
775 portletId + PortletConstants.WAR_SEPARATOR +
776 servletContextName;
777 }
778
779 portletId = PortalUtil.getJsSafePortletId(portletId);
780
781 portletIds.add(portletId);
782 curPortletIds.add(portletId);
783 }
784
785 _readLiferayDisplay(
786 servletContextName, category, curPortletCategory, portletIds);
787 }
788 }
789
790 private PortletCategory _readLiferayDisplayXML(String xml)
791 throws Exception {
792
793 return _readLiferayDisplayXML(null, xml);
794 }
795
796 private PortletCategory _readLiferayDisplayXML(
797 String servletContextName, String xml)
798 throws Exception {
799
800 PortletCategory portletCategory = new PortletCategory();
801
802 if (xml == null) {
803 xml = ContentUtil.get(
804 "com/liferay/portal/deploy/dependencies/liferay-display.xml");
805 }
806
807 Document doc = SAXReaderUtil.read(xml, true);
808
809 Element root = doc.getRootElement();
810
811 Set<String> portletIds = new HashSet<String>();
812
813 _readLiferayDisplay(
814 servletContextName, root, portletCategory, portletIds);
815
816
819 Set<String> undefinedPortletIds = new HashSet<String>();
820
821 Iterator<Portlet> itr = _getPortletsPool().values().iterator();
822
823 while (itr.hasNext()) {
824 Portlet portlet = itr.next();
825
826 String portletId = portlet.getPortletId();
827
828 PortletApp portletApp = portlet.getPortletApp();
829
830 if ((servletContextName != null) && (portletApp.isWARFile()) &&
831 (portletId.endsWith(
832 PortletConstants.WAR_SEPARATOR +
833 PortalUtil.getJsSafePortletId(servletContextName)) &&
834 (!portletIds.contains(portletId)))) {
835
836 undefinedPortletIds.add(portletId);
837 }
838 else if ((servletContextName == null) &&
839 (!portletApp.isWARFile()) &&
840 (portletId.indexOf(
841 PortletConstants.WAR_SEPARATOR) == -1) &&
842 (!portletIds.contains(portletId))) {
843
844 undefinedPortletIds.add(portletId);
845 }
846 }
847
848 if (undefinedPortletIds.size() > 0) {
849 PortletCategory undefinedCategory = new PortletCategory(
850 "category.undefined");
851
852 portletCategory.addCategory(undefinedCategory);
853
854 undefinedCategory.getPortletIds().addAll(undefinedPortletIds);
855 }
856
857 return portletCategory;
858 }
859
860 private Set<String> _readLiferayPortletXML(
861 String xml, Map<String, Portlet> portletsPool)
862 throws Exception {
863
864 return _readLiferayPortletXML(StringPool.BLANK, xml, portletsPool);
865 }
866
867 private Set<String> _readLiferayPortletXML(
868 String servletContextName, String xml,
869 Map<String, Portlet> portletsPool)
870 throws Exception {
871
872 Set<String> liferayPortletIds = new HashSet<String>();
873
874 if (xml == null) {
875 return liferayPortletIds;
876 }
877
878 Document doc = SAXReaderUtil.read(xml, true);
879
880 Element root = doc.getRootElement();
881
882 PortletApp portletApp = _getPortletApp(servletContextName);
883
884 Map<String, String> roleMappers = new HashMap<String, String>();
885
886 Iterator<Element> itr1 = root.elements("role-mapper").iterator();
887
888 while (itr1.hasNext()) {
889 Element roleMapper = itr1.next();
890
891 String roleName = roleMapper.elementText("role-name");
892 String roleLink = roleMapper.elementText("role-link");
893
894 roleMappers.put(roleName, roleLink);
895 }
896
897 Map<String, String> customUserAttributes =
898 portletApp.getCustomUserAttributes();
899
900 itr1 = root.elements("custom-user-attribute").iterator();
901
902 while (itr1.hasNext()) {
903 Element customUserAttribute = itr1.next();
904
905 String customClass = customUserAttribute.elementText(
906 "custom-class");
907
908 Iterator<Element> itr2 = customUserAttribute.elements(
909 "name").iterator();
910
911 while (itr2.hasNext()) {
912 Element nameEl = itr2.next();
913
914 String name = nameEl.getText();
915
916 customUserAttributes.put(name, customClass);
917 }
918 }
919
920 itr1 = root.elements("portlet").iterator();
921
922 while (itr1.hasNext()) {
923 Element portlet = itr1.next();
924
925 String portletId = portlet.elementText("portlet-name");
926
927 if (Validator.isNotNull(servletContextName)) {
928 portletId =
929 portletId + PortletConstants.WAR_SEPARATOR +
930 servletContextName;
931 }
932
933 portletId = PortalUtil.getJsSafePortletId(portletId);
934
935 if (_log.isDebugEnabled()) {
936 _log.debug("Reading portlet extension " + portletId);
937 }
938
939 liferayPortletIds.add(portletId);
940
941 Portlet portletModel = portletsPool.get(portletId);
942
943 if (portletModel != null) {
944 portletModel.setIcon(GetterUtil.getString(
945 portlet.elementText("icon"), portletModel.getIcon()));
946 portletModel.setVirtualPath(GetterUtil.getString(
947 portlet.elementText("virtual-path"),
948 portletModel.getVirtualPath()));
949 portletModel.setStrutsPath(GetterUtil.getString(
950 portlet.elementText("struts-path"),
951 portletModel.getStrutsPath()));
952
953 if (Validator.isNotNull(
954 portlet.elementText("configuration-path"))) {
955
956 _log.error(
957 "The configuration-path element is no longer " +
958 "supported. Use configuration-action-class " +
959 "instead.");
960 }
961
962 portletModel.setConfigurationActionClass(GetterUtil.getString(
963 portlet.elementText("configuration-action-class"),
964 portletModel.getConfigurationActionClass()));
965 portletModel.setIndexerClass(GetterUtil.getString(
966 portlet.elementText("indexer-class"),
967 portletModel.getIndexerClass()));
968 portletModel.setOpenSearchClass(GetterUtil.getString(
969 portlet.elementText("open-search-class"),
970 portletModel.getOpenSearchClass()));
971 portletModel.setSchedulerClass(GetterUtil.getString(
972 portlet.elementText("scheduler-class"),
973 portletModel.getSchedulerClass()));
974 portletModel.setPortletURLClass(GetterUtil.getString(
975 portlet.elementText("portlet-url-class"),
976 portletModel.getPortletURLClass()));
977
978 portletModel.setFriendlyURLMapperClass(GetterUtil.getString(
979 portlet.elementText("friendly-url-mapper-class"),
980 portletModel.getFriendlyURLMapperClass()));
981
982 if (Validator.isNull(
983 portletModel.getFriendlyURLMapperClass())) {
984
985 _friendlyURLMapperPortlets.remove(portletId);
986 }
987 else {
988 _friendlyURLMapperPortlets.put(portletId, portletModel);
989 }
990
991 portletModel.setURLEncoderClass(GetterUtil.getString(
992 portlet.elementText("url-encoder-class"),
993 portletModel.getURLEncoderClass()));
994 portletModel.setPortletDataHandlerClass(GetterUtil.getString(
995 portlet.elementText("portlet-data-handler-class"),
996 portletModel.getPortletDataHandlerClass()));
997 portletModel.setPortletLayoutListenerClass(GetterUtil.getString(
998 portlet.elementText("portlet-layout-listener-class"),
999 portletModel.getPortletLayoutListenerClass()));
1000 portletModel.setPollerProcessorClass(GetterUtil.getString(
1001 portlet.elementText("poller-processor-class"),
1002 portletModel.getPollerProcessorClass()));
1003 portletModel.setPopMessageListenerClass(GetterUtil.getString(
1004 portlet.elementText("pop-message-listener-class"),
1005 portletModel.getPopMessageListenerClass()));
1006 portletModel.setSocialActivityInterpreterClass(
1007 GetterUtil.getString(
1008 portlet.elementText(
1009 "social-activity-interpreter-class"),
1010 portletModel.getSocialActivityInterpreterClass()));
1011 portletModel.setSocialRequestInterpreterClass(
1012 GetterUtil.getString(
1013 portlet.elementText(
1014 "social-request-interpreter-class"),
1015 portletModel.getSocialRequestInterpreterClass()));
1016 portletModel.setPreferencesCompanyWide(GetterUtil.getBoolean(
1017 portlet.elementText("preferences-company-wide"),
1018 portletModel.isPreferencesCompanyWide()));
1019 portletModel.setPreferencesUniquePerLayout(
1020 GetterUtil.getBoolean(
1021 portlet.elementText("preferences-unique-per-layout"),
1022 portletModel.isPreferencesUniquePerLayout()));
1023 portletModel.setPreferencesOwnedByGroup(GetterUtil.getBoolean(
1024 portlet.elementText("preferences-owned-by-group"),
1025 portletModel.isPreferencesOwnedByGroup()));
1026 portletModel.setUseDefaultTemplate(GetterUtil.getBoolean(
1027 portlet.elementText("use-default-template"),
1028 portletModel.isUseDefaultTemplate()));
1029 portletModel.setShowPortletAccessDenied(GetterUtil.getBoolean(
1030 portlet.elementText("show-portlet-access-denied"),
1031 portletModel.isShowPortletAccessDenied()));
1032 portletModel.setShowPortletInactive(GetterUtil.getBoolean(
1033 portlet.elementText("show-portlet-inactive"),
1034 portletModel.isShowPortletInactive()));
1035 portletModel.setActionURLRedirect(GetterUtil.getBoolean(
1036 portlet.elementText("action-url-redirect"),
1037 portletModel.isActionURLRedirect()));
1038 portletModel.setRestoreCurrentView(GetterUtil.getBoolean(
1039 portlet.elementText("restore-current-view"),
1040 portletModel.isRestoreCurrentView()));
1041 portletModel.setMaximizeEdit(GetterUtil.getBoolean(
1042 portlet.elementText("maximize-edit"),
1043 portletModel.isMaximizeEdit()));
1044 portletModel.setMaximizeHelp(GetterUtil.getBoolean(
1045 portlet.elementText("maximize-help"),
1046 portletModel.isMaximizeHelp()));
1047 portletModel.setPopUpPrint(GetterUtil.getBoolean(
1048 portlet.elementText("pop-up-print"),
1049 portletModel.isPopUpPrint()));
1050 portletModel.setLayoutCacheable(GetterUtil.getBoolean(
1051 portlet.elementText("layout-cacheable"),
1052 portletModel.isLayoutCacheable()));
1053 portletModel.setInstanceable(GetterUtil.getBoolean(
1054 portlet.elementText("instanceable"),
1055 portletModel.isInstanceable()));
1056 portletModel.setUserPrincipalStrategy(GetterUtil.getString(
1057 portlet.elementText("user-principal-strategy"),
1058 portletModel.getUserPrincipalStrategy()));
1059 portletModel.setPrivateRequestAttributes(GetterUtil.getBoolean(
1060 portlet.elementText("private-request-attributes"),
1061 portletModel.isPrivateRequestAttributes()));
1062 portletModel.setPrivateSessionAttributes(GetterUtil.getBoolean(
1063 portlet.elementText("private-session-attributes"),
1064 portletModel.isPrivateSessionAttributes()));
1065 portletModel.setRenderWeight(GetterUtil.getInteger(
1066 portlet.elementText("render-weight"),
1067 portletModel.getRenderWeight()));
1068 portletModel.setAjaxable(GetterUtil.getBoolean(
1069 portlet.elementText("ajaxable"),
1070 portletModel.isAjaxable()));
1071
1072 List<String> headerPortalCssList =
1073 portletModel.getHeaderPortalCss();
1074
1075 Iterator<Element> itr2 = portlet.elements(
1076 "header-portal-css").iterator();
1077
1078 while (itr2.hasNext()) {
1079 Element headerPortalCssEl = itr2.next();
1080
1081 headerPortalCssList.add(headerPortalCssEl.getText());
1082 }
1083
1084 List<String> headerPortletCssList =
1085 portletModel.getHeaderPortletCss();
1086
1087 List<Element> list = new ArrayList<Element>();
1088
1089 list.addAll(portlet.elements("header-css"));
1090 list.addAll(portlet.elements("header-portlet-css"));
1091
1092 itr2 = list.iterator();
1093
1094 while (itr2.hasNext()) {
1095 Element headerPortletCssEl = itr2.next();
1096
1097 headerPortletCssList.add(headerPortletCssEl.getText());
1098 }
1099
1100 List<String> headerPortalJavaScriptList =
1101 portletModel.getHeaderPortalJavaScript();
1102
1103 itr2 = portlet.elements("header-portal-javascript").iterator();
1104
1105 while (itr2.hasNext()) {
1106 Element headerPortalJavaScriptEl = itr2.next();
1107
1108 headerPortalJavaScriptList.add(
1109 headerPortalJavaScriptEl.getText());
1110 }
1111
1112 List<String> headerPortletJavaScriptList =
1113 portletModel.getHeaderPortletJavaScript();
1114
1115 list.clear();
1116
1117 list.addAll(portlet.elements("header-javascript"));
1118 list.addAll(portlet.elements("header-portlet-javascript"));
1119
1120 itr2 = list.iterator();
1121
1122 while (itr2.hasNext()) {
1123 Element headerPortletJavaScriptEl = itr2.next();
1124
1125 headerPortletJavaScriptList.add(
1126 headerPortletJavaScriptEl.getText());
1127 }
1128
1129 List<String> footerPortalCssList =
1130 portletModel.getFooterPortalCss();
1131
1132 itr2 = portlet.elements("footer-portal-css").iterator();
1133
1134 while (itr2.hasNext()) {
1135 Element footerPortalCssEl = itr2.next();
1136
1137 footerPortalCssList.add(footerPortalCssEl.getText());
1138 }
1139
1140 List<String> footerPortletCssList =
1141 portletModel.getFooterPortletCss();
1142
1143 itr2 = portlet.elements("footer-portlet-css").iterator();
1144
1145 while (itr2.hasNext()) {
1146 Element footerPortletCssEl = itr2.next();
1147
1148 footerPortletCssList.add(footerPortletCssEl.getText());
1149 }
1150
1151 List<String> footerPortalJavaScriptList =
1152 portletModel.getFooterPortalJavaScript();
1153
1154 itr2 = portlet.elements("footer-portal-javascript").iterator();
1155
1156 while (itr2.hasNext()) {
1157 Element footerPortalJavaScriptEl = itr2.next();
1158
1159 footerPortalJavaScriptList.add(
1160 footerPortalJavaScriptEl.getText());
1161 }
1162
1163 List<String> footerPortletJavaScriptList =
1164 portletModel.getFooterPortletJavaScript();
1165
1166 itr2 = portlet.elements("footer-portlet-javascript").iterator();
1167
1168 while (itr2.hasNext()) {
1169 Element footerPortletJavaScriptEl = itr2.next();
1170
1171 footerPortletJavaScriptList.add(
1172 footerPortletJavaScriptEl.getText());
1173 }
1174
1175 portletModel.setCssClassWrapper(GetterUtil.getString(
1176 portlet.elementText("css-class-wrapper"),
1177 portletModel.getCssClassWrapper()));
1178 portletModel.setFacebookIntegration(GetterUtil.getString(
1179 portlet.elementText("facebook-integration"),
1180 portletModel.getFacebookIntegration()));
1181 portletModel.setAddDefaultResource(GetterUtil.getBoolean(
1182 portlet.elementText("add-default-resource"),
1183 portletModel.isAddDefaultResource()));
1184 portletModel.setSystem(GetterUtil.getBoolean(
1185 portlet.elementText("system"),
1186 portletModel.isSystem()));
1187 portletModel.setActive(GetterUtil.getBoolean(
1188 portlet.elementText("active"),
1189 portletModel.isActive()));
1190 portletModel.setInclude(GetterUtil.getBoolean(
1191 portlet.elementText("include"),
1192 portletModel.isInclude()));
1193
1194 if (!portletModel.isAjaxable() &&
1195 (portletModel.getRenderWeight() < 1)) {
1196
1197 portletModel.setRenderWeight(1);
1198 }
1199
1200 portletModel.getRoleMappers().putAll(roleMappers);
1201 portletModel.linkRoles();
1202 }
1203 }
1204
1205 return liferayPortletIds;
1206 }
1207
1208 private Set<String> _readPortletXML(
1209 ServletContext servletContext, String xml,
1210 Map<String, Portlet> portletsPool, List<String> servletURLPatterns,
1211 PluginPackage pluginPackage)
1212 throws Exception {
1213
1214 return _readPortletXML(
1215 StringPool.BLANK, servletContext, xml, portletsPool,
1216 servletURLPatterns, pluginPackage);
1217 }
1218
1219 private Set<String> _readPortletXML(
1220 String servletContextName, ServletContext servletContext,
1221 String xml, Map<String, Portlet> portletsPool,
1222 List<String> servletURLPatterns, PluginPackage pluginPackage)
1223 throws Exception {
1224
1225 Set<String> portletIds = new HashSet<String>();
1226
1227 if (xml == null) {
1228 return portletIds;
1229 }
1230
1231 boolean portletXMLValidate = PropsValues.PORTLET_XML_VALIDATE;
1232
1233 if (ServerDetector.isGeronimo()) {
1234 portletXMLValidate = false;
1235 }
1236
1237 Document doc = SAXReaderUtil.read(xml, portletXMLValidate);
1238
1239 Element root = doc.getRootElement();
1240
1241 PortletApp portletApp = _getPortletApp(servletContextName);
1242
1243 portletApp.getServletURLPatterns().addAll(servletURLPatterns);
1244
1245 Set<String> userAttributes = portletApp.getUserAttributes();
1246
1247 Iterator<Element> itr1 = root.elements("user-attribute").iterator();
1248
1249 while (itr1.hasNext()) {
1250 Element userAttribute = itr1.next();
1251
1252 String name = userAttribute.elementText("name");
1253
1254 userAttributes.add(name);
1255 }
1256
1257 String defaultNamespace = root.elementText("default-namespace");
1258
1259 if (Validator.isNotNull(defaultNamespace)) {
1260 portletApp.setDefaultNamespace(defaultNamespace);
1261 }
1262
1263 itr1 = root.elements("event-definition").iterator();
1264
1265 while (itr1.hasNext()) {
1266 Element eventDefinitionEl = itr1.next();
1267
1268 Element qNameEl = eventDefinitionEl.element("qname");
1269 Element nameEl = eventDefinitionEl.element("name");
1270 String valueType = eventDefinitionEl.elementText("value-type");
1271
1272 QName qName = QNameUtil.getQName(
1273 qNameEl, nameEl, portletApp.getDefaultNamespace());
1274
1275 EventDefinition eventDefinition = new EventDefinitionImpl(
1276 qName, valueType, portletApp);
1277
1278 portletApp.addEventDefinition(eventDefinition);
1279 }
1280
1281 itr1 = root.elements("public-render-parameter").iterator();
1282
1283 while (itr1.hasNext()) {
1284 Element publicRenderParameterEl = itr1.next();
1285
1286 String identifier = publicRenderParameterEl.elementText(
1287 "identifier");
1288 Element qNameEl = publicRenderParameterEl.element("qname");
1289 Element nameEl = publicRenderParameterEl.element("name");
1290
1291 QName qName = QNameUtil.getQName(
1292 qNameEl, nameEl, portletApp.getDefaultNamespace());
1293
1294 PublicRenderParameter publicRenderParameter =
1295 new PublicRenderParameterImpl(identifier, qName, portletApp);
1296
1297 portletApp.addPublicRenderParameter(publicRenderParameter);
1298 }
1299
1300 itr1 = root.elements("container-runtime-option").iterator();
1301
1302 while (itr1.hasNext()) {
1303 Element containerRuntimeOption = itr1.next();
1304
1305 String name = GetterUtil.getString(
1306 containerRuntimeOption.elementText("name"));
1307
1308 List<String> values = new ArrayList<String>();
1309
1310 for (Element value : containerRuntimeOption.elements("value")) {
1311 values.add(value.getTextTrim());
1312 }
1313
1314 portletApp.getContainerRuntimeOptions().put(
1315 name, values.toArray(new String[values.size()]));
1316
1317 if (name.equals(PortletConfigImpl.RUNTIME_OPTION_PORTAL_CONTEXT) &&
1318 !values.isEmpty() && GetterUtil.getBoolean(values.get(0))) {
1319
1320 portletApp.setWARFile(false);
1321 }
1322 }
1323
1324 long timestamp = ServletContextUtil.getLastModified(servletContext);
1325
1326 itr1 = root.elements("portlet").iterator();
1327
1328 while (itr1.hasNext()) {
1329 Element portlet = itr1.next();
1330
1331 String portletName = portlet.elementText("portlet-name");
1332
1333 String portletId = portletName;
1334
1335 if (Validator.isNotNull(servletContextName)) {
1336 portletId =
1337 portletId + PortletConstants.WAR_SEPARATOR +
1338 servletContextName;
1339 }
1340
1341 portletId = PortalUtil.getJsSafePortletId(portletId);
1342
1343 if (_log.isDebugEnabled()) {
1344 _log.debug("Reading portlet " + portletId);
1345 }
1346
1347 portletIds.add(portletId);
1348
1349 Portlet portletModel = portletsPool.get(portletId);
1350
1351 if (portletModel == null) {
1352 portletModel = new PortletImpl(
1353 CompanyConstants.SYSTEM, portletId);
1354
1355 portletsPool.put(portletId, portletModel);
1356 }
1357
1358 portletModel.setTimestamp(timestamp);
1359
1360 portletModel.setPluginPackage(pluginPackage);
1361 portletModel.setPortletApp(portletApp);
1362
1363 portletModel.setPortletName(portletName);
1364 portletModel.setDisplayName(GetterUtil.getString(
1365 portlet.elementText("display-name"),
1366 portletModel.getDisplayName()));
1367 portletModel.setPortletClass(GetterUtil.getString(
1368 portlet.elementText("portlet-class")));
1369
1370 Iterator<Element> itr2 = portlet.elements("init-param").iterator();
1371
1372 while (itr2.hasNext()) {
1373 Element initParam = itr2.next();
1374
1375 portletModel.getInitParams().put(
1376 initParam.elementText("name"),
1377 initParam.elementText("value"));
1378 }
1379
1380 Element expirationCache = portlet.element("expiration-cache");
1381
1382 if (expirationCache != null) {
1383 portletModel.setExpCache(new Integer(GetterUtil.getInteger(
1384 expirationCache.getText())));
1385 }
1386
1387 itr2 = portlet.elements("supports").iterator();
1388
1389 while (itr2.hasNext()) {
1390 Element supports = itr2.next();
1391
1392 String mimeType = supports.elementText("mime-type");
1393
1394 Set<String> mimeTypePortletModes =
1395 portletModel.getPortletModes().get(mimeType);
1396
1397 if (mimeTypePortletModes == null) {
1398 mimeTypePortletModes = new HashSet<String>();
1399
1400 portletModel.getPortletModes().put(
1401 mimeType, mimeTypePortletModes);
1402 }
1403
1404 mimeTypePortletModes.add(
1405 PortletMode.VIEW.toString().toLowerCase());
1406
1407 Iterator<Element> itr3 = supports.elements(
1408 "portlet-mode").iterator();
1409
1410 while (itr3.hasNext()) {
1411 Element portletMode = itr3.next();
1412
1413 mimeTypePortletModes.add(
1414 portletMode.getTextTrim().toLowerCase());
1415 }
1416
1417 Set<String> mimeTypeWindowStates =
1418 portletModel.getWindowStates().get(mimeType);
1419
1420 if (mimeTypeWindowStates == null) {
1421 mimeTypeWindowStates = new HashSet<String>();
1422
1423 portletModel.getWindowStates().put(
1424 mimeType, mimeTypeWindowStates);
1425 }
1426
1427 mimeTypeWindowStates.add(
1428 WindowState.NORMAL.toString().toLowerCase());
1429
1430 itr3 = supports.elements("window-state").iterator();
1431
1432 if (!itr3.hasNext()) {
1433 mimeTypeWindowStates.add(
1434 WindowState.MAXIMIZED.toString().toLowerCase());
1435 mimeTypeWindowStates.add(
1436 WindowState.MINIMIZED.toString().toLowerCase());
1437 mimeTypeWindowStates.add(
1438 LiferayWindowState.EXCLUSIVE.toString().toLowerCase());
1439 mimeTypeWindowStates.add(
1440 LiferayWindowState.POP_UP.toString().toLowerCase());
1441 }
1442
1443 while (itr3.hasNext()) {
1444 Element windowState = itr3.next();
1445
1446 mimeTypeWindowStates.add(
1447 windowState.getTextTrim().toLowerCase());
1448 }
1449 }
1450
1451 Set<String> supportedLocales = portletModel.getSupportedLocales();
1452
1453
1456 itr2 = portlet.elements("supported-locale").iterator();
1457
1458 while (itr2.hasNext()) {
1459 Element supportedLocaleEl = itr2.next();
1460
1461 String supportedLocale = supportedLocaleEl.getText();
1462
1463 supportedLocales.add(supportedLocale);
1464 }
1465
1466 portletModel.setResourceBundle(
1467 portlet.elementText("resource-bundle"));
1468
1469 Element portletInfo = portlet.element("portlet-info");
1470
1471 String portletInfoTitle = null;
1472 String portletInfoShortTitle = null;
1473 String portletInfoKeyWords = null;
1474
1475 if (portletInfo != null) {
1476 portletInfoTitle = portletInfo.elementText("title");
1477 portletInfoShortTitle = portletInfo.elementText("short-title");
1478 portletInfoKeyWords = portletInfo.elementText("keywords");
1479 }
1480
1481 portletModel.setPortletInfo(new PortletInfo(
1482 portletInfoTitle, portletInfoShortTitle, portletInfoKeyWords));
1483
1484 Element portletPreferences = portlet.element("portlet-preferences");
1485
1486 String defaultPreferences = null;
1487 String prefsValidator = null;
1488
1489 if (portletPreferences != null) {
1490 Element prefsValidatorEl =
1491 portletPreferences.element("preferences-validator");
1492
1493 if (prefsValidatorEl != null) {
1494 prefsValidator = prefsValidatorEl.getText();
1495
1496 portletPreferences.remove(prefsValidatorEl);
1497 }
1498
1499 defaultPreferences = portletPreferences.asXML();
1500 }
1501
1502 portletModel.setDefaultPreferences(defaultPreferences);
1503 portletModel.setPreferencesValidator(prefsValidator);
1504
1505 if (!portletApp.isWARFile() &&
1506 Validator.isNotNull(prefsValidator) &&
1507 PropsValues.PREFERENCE_VALIDATE_ON_STARTUP) {
1508
1509 try {
1510 PreferencesValidator prefsValidatorObj =
1511 PortalUtil.getPreferencesValidator(portletModel);
1512
1513 prefsValidatorObj.validate(
1514 PortletPreferencesSerializer.fromDefaultXML(
1515 defaultPreferences));
1516 }
1517 catch (Exception e) {
1518 if (_log.isWarnEnabled()) {
1519 _log.warn(
1520 "Portlet with the name " + portletId +
1521 " does not have valid default preferences");
1522 }
1523 }
1524 }
1525
1526 Set<String> unlikedRoles = portletModel.getUnlinkedRoles();
1527
1528 itr2 = portlet.elements("security-role-ref").iterator();
1529
1530 while (itr2.hasNext()) {
1531 Element role = itr2.next();
1532
1533 unlikedRoles.add(role.elementText("role-name"));
1534 }
1535
1536 itr2 = portlet.elements("supported-processing-event").iterator();
1537
1538 while (itr2.hasNext()) {
1539 Element supportedProcessingEvent = itr2.next();
1540
1541 Element qNameEl = supportedProcessingEvent.element("qname");
1542 Element nameEl = supportedProcessingEvent.element("name");
1543
1544 QName qName = QNameUtil.getQName(
1545 qNameEl, nameEl, portletApp.getDefaultNamespace());
1546
1547 portletModel.addProcessingEvent(qName);
1548 }
1549
1550 itr2 = portlet.elements("supported-publishing-event").iterator();
1551
1552 while (itr2.hasNext()) {
1553 Element supportedPublishingEvent = itr2.next();
1554
1555 Element qNameEl = supportedPublishingEvent.element("qname");
1556 Element nameEl = supportedPublishingEvent.element("name");
1557
1558 QName qName = QNameUtil.getQName(
1559 qNameEl, nameEl, portletApp.getDefaultNamespace());
1560
1561 portletModel.addPublishingEvent(qName);
1562 }
1563
1564 itr2 = portlet.elements(
1565 "supported-public-render-parameter").iterator();
1566
1567 while (itr2.hasNext()) {
1568 Element supportedPublicRenderParameter = itr2.next();
1569
1570 String identifier =
1571 supportedPublicRenderParameter.getTextTrim();
1572
1573 PublicRenderParameter publicRenderParameter =
1574 portletApp.getPublicRenderParameter(identifier);
1575
1576 if (publicRenderParameter == null) {
1577 _log.error(
1578 "Supported public render parameter references " +
1579 "unnknown identifier " + identifier);
1580
1581 continue;
1582 }
1583
1584 portletModel.addPublicRenderParameter(publicRenderParameter);
1585 }
1586 }
1587
1588 itr1 = root.elements("filter").iterator();
1589
1590 while (itr1.hasNext()) {
1591 Element filter = itr1.next();
1592
1593 String filterName = filter.elementText("filter-name");
1594 String filterClass = filter.elementText("filter-class");
1595
1596 Set<String> lifecycles = new LinkedHashSet<String>();
1597
1598 Iterator<Element> itr2 = filter.elements("lifecycle").iterator();
1599
1600 while (itr2.hasNext()) {
1601 Element lifecycle = itr2.next();
1602
1603 lifecycles.add(lifecycle.getText());
1604 }
1605
1606 Map<String, String> initParams = new HashMap<String, String>();
1607
1608 itr2 = filter.elements("init-param").iterator();
1609
1610 while (itr2.hasNext()) {
1611 Element initParam = itr2.next();
1612
1613 initParams.put(
1614 initParam.elementText("name"),
1615 initParam.elementText("value"));
1616 }
1617
1618 PortletFilter portletFilter = new PortletFilterImpl(
1619 filterName, filterClass, lifecycles, initParams, portletApp);
1620
1621 portletApp.addPortletFilter(portletFilter);
1622 }
1623
1624 itr1 = root.elements("filter-mapping").iterator();
1625
1626 while (itr1.hasNext()) {
1627 Element filterMapping = itr1.next();
1628
1629 String filterName = filterMapping.elementText("filter-name");
1630
1631 Iterator<Element> itr2 = filterMapping.elements(
1632 "portlet-name").iterator();
1633
1634 while (itr2.hasNext()) {
1635 Element portletNameEl = itr2.next();
1636
1637 String portletName = portletNameEl.getTextTrim();
1638
1639 PortletFilter portletFilter = portletApp.getPortletFilter(
1640 filterName);
1641
1642 if (portletFilter == null) {
1643 _log.error(
1644 "Filter mapping references unnknown filter name " +
1645 filterName);
1646
1647 continue;
1648 }
1649
1650 List<Portlet> portletModels = _getPortletsByPortletName(
1651 portletName, servletContextName, portletsPool);
1652
1653 if (portletModels.size() == 0) {
1654 _log.error(
1655 "Filter mapping with filter name " + filterName +
1656 " references unnknown portlet name " + portletName);
1657 }
1658
1659 for (Portlet portletModel : portletModels) {
1660 portletModel.getPortletFilters().put(
1661 filterName, portletFilter);
1662 }
1663 }
1664 }
1665
1666 itr1 = root.elements("listener").iterator();
1667
1668 while (itr1.hasNext()) {
1669 Element listener = itr1.next();
1670
1671 String listenerClass = listener.elementText("listener-class");
1672
1673 PortletURLListener portletURLListener = new PortletURLListenerImpl(
1674 listenerClass, portletApp);
1675
1676 portletApp.addPortletURLListener(portletURLListener);
1677 }
1678
1679 return portletIds;
1680 }
1681
1682 private List<String> _readWebXML(String xml) throws Exception {
1683 List<String> servletURLPatterns = new ArrayList<String>();
1684
1685 if (xml == null) {
1686 return servletURLPatterns;
1687 }
1688
1689 Document doc = SAXReaderUtil.read(xml);
1690
1691 Element root = doc.getRootElement();
1692
1693 Iterator<Element> itr = root.elements("servlet-mapping").iterator();
1694
1695 while (itr.hasNext()) {
1696 Element servletMapping = itr.next();
1697
1698 String urlPattern = servletMapping.elementText("url-pattern");
1699
1700 servletURLPatterns.add(urlPattern);
1701 }
1702
1703 return servletURLPatterns;
1704
1705 }
1706
1707 private void _setSpriteImages(
1708 ServletContext servletContext, PortletApp portletApp,
1709 String resourcePath)
1710 throws Exception {
1711
1712 Set<String> resourcePaths = servletContext.getResourcePaths(
1713 resourcePath);
1714
1715 if (resourcePaths == null) {
1716 return;
1717 }
1718
1719 List<File> images = new ArrayList<File>(resourcePaths.size());
1720
1721 for (String curResourcePath : resourcePaths) {
1722 if (curResourcePath.endsWith(StringPool.SLASH)) {
1723 _setSpriteImages(servletContext, portletApp, curResourcePath);
1724 }
1725 else if (curResourcePath.endsWith(".png")) {
1726 String realPath = ServletContextUtil.getRealPath(
1727 servletContext, curResourcePath);
1728
1729 if (realPath != null) {
1730 images.add(new File(realPath));
1731 }
1732 else {
1733 if (ServerDetector.isTomcat()) {
1734 if (_log.isInfoEnabled()) {
1735 _log.info(ServletContextUtil.LOG_INFO_SPRITES);
1736 }
1737 }
1738 else {
1739 _log.error(
1740 "Real path for " + curResourcePath + " is null");
1741 }
1742 }
1743 }
1744 }
1745
1746 String spriteFileName = ".sprite.png";
1747 String spritePropertiesFileName = ".sprite.properties";
1748 String spritePropertiesRootPath = ServletContextUtil.getRealPath(
1749 servletContext, StringPool.SLASH);
1750
1751 Properties spriteProperties = SpriteProcessorUtil.generate(
1752 images, spriteFileName, spritePropertiesFileName,
1753 spritePropertiesRootPath, 16, 16, 10240);
1754
1755 if (spriteProperties == null) {
1756 return;
1757 }
1758
1759 spriteFileName =
1760 resourcePath.substring(0, resourcePath.length()) + spriteFileName;
1761
1762 portletApp.setSpriteImages(spriteFileName, spriteProperties);
1763 }
1764
1765 private static final String _WSRP_CATEGORY = "category.wsrp";
1766
1767 private static Log _log =
1768 LogFactoryUtil.getLog(PortletLocalServiceImpl.class);
1769
1770 private static Map<String, PortletApp> _portletAppsPool =
1771 new ConcurrentHashMap<String, PortletApp>();
1772 private static Map<String, Portlet> _portletsPool =
1773 new ConcurrentHashMap<String, Portlet>();
1774 private static Map<Long, Map<String, Portlet>> _companyPortletsPool =
1775 new ConcurrentHashMap<Long, Map<String, Portlet>>();
1776 private static Map<String, String> _portletIdsByStrutsPath =
1777 new ConcurrentHashMap<String, String>();
1778 private static Map<String, Portlet> _friendlyURLMapperPortlets =
1779 new ConcurrentHashMap<String, Portlet>();
1780
1781}