1
22
23 package com.liferay.portal.util;
24
25 import com.liferay.portal.NoSuchCompanyException;
26 import com.liferay.portal.NoSuchLayoutException;
27 import com.liferay.portal.NoSuchUserException;
28 import com.liferay.portal.PortalException;
29 import com.liferay.portal.SystemException;
30 import com.liferay.portal.kernel.bean.BeanPropertiesUtil;
31 import com.liferay.portal.kernel.configuration.Filter;
32 import com.liferay.portal.kernel.language.LanguageUtil;
33 import com.liferay.portal.kernel.portlet.FriendlyURLMapper;
34 import com.liferay.portal.kernel.portlet.LiferayPortletMode;
35 import com.liferay.portal.kernel.portlet.PortletBag;
36 import com.liferay.portal.kernel.portlet.PortletBagPool;
37 import com.liferay.portal.kernel.servlet.HttpMethods;
38 import com.liferay.portal.kernel.servlet.SessionErrors;
39 import com.liferay.portal.kernel.servlet.StringServletResponse;
40 import com.liferay.portal.kernel.upload.UploadPortletRequest;
41 import com.liferay.portal.kernel.upload.UploadServletRequest;
42 import com.liferay.portal.kernel.util.ArrayUtil;
43 import com.liferay.portal.kernel.util.CalendarFactoryUtil;
44 import com.liferay.portal.kernel.util.CharPool;
45 import com.liferay.portal.kernel.util.ContentTypes;
46 import com.liferay.portal.kernel.util.GetterUtil;
47 import com.liferay.portal.kernel.util.Http;
48 import com.liferay.portal.kernel.util.HttpUtil;
49 import com.liferay.portal.kernel.util.InstancePool;
50 import com.liferay.portal.kernel.util.JavaConstants;
51 import com.liferay.portal.kernel.util.LocaleUtil;
52 import com.liferay.portal.kernel.util.ParamUtil;
53 import com.liferay.portal.kernel.util.StringComparator;
54 import com.liferay.portal.kernel.util.StringPool;
55 import com.liferay.portal.kernel.util.StringUtil;
56 import com.liferay.portal.kernel.util.UnicodeProperties;
57 import com.liferay.portal.kernel.util.Validator;
58 import com.liferay.portal.model.ClassName;
59 import com.liferay.portal.model.Company;
60 import com.liferay.portal.model.Group;
61 import com.liferay.portal.model.GroupConstants;
62 import com.liferay.portal.model.Layout;
63 import com.liferay.portal.model.LayoutConstants;
64 import com.liferay.portal.model.LayoutSet;
65 import com.liferay.portal.model.LayoutTypePortlet;
66 import com.liferay.portal.model.Organization;
67 import com.liferay.portal.model.Portlet;
68 import com.liferay.portal.model.PortletApp;
69 import com.liferay.portal.model.RoleConstants;
70 import com.liferay.portal.model.User;
71 import com.liferay.portal.model.UserGroup;
72 import com.liferay.portal.plugin.PluginPackageUtil;
73 import com.liferay.portal.portletcontainer.HttpServletUtil;
74 import com.liferay.portal.security.auth.PrincipalException;
75 import com.liferay.portal.security.permission.ActionKeys;
76 import com.liferay.portal.security.permission.PermissionChecker;
77 import com.liferay.portal.security.permission.PermissionCheckerFactory;
78 import com.liferay.portal.service.ClassNameServiceUtil;
79 import com.liferay.portal.service.CompanyLocalServiceUtil;
80 import com.liferay.portal.service.GroupLocalServiceUtil;
81 import com.liferay.portal.service.LayoutLocalServiceUtil;
82 import com.liferay.portal.service.PortletLocalServiceUtil;
83 import com.liferay.portal.service.UserLocalServiceUtil;
84 import com.liferay.portal.service.UserServiceUtil;
85 import com.liferay.portal.service.permission.UserPermissionUtil;
86 import com.liferay.portal.theme.ThemeDisplay;
87 import com.liferay.portal.tools.sql.DBUtil;
88 import com.liferay.portal.upload.UploadPortletRequestImpl;
89 import com.liferay.portal.upload.UploadServletRequestImpl;
90 import com.liferay.portlet.ActionRequestImpl;
91 import com.liferay.portlet.ActionResponseImpl;
92 import com.liferay.portlet.PortletConfigFactory;
93 import com.liferay.portlet.PortletConfigImpl;
94 import com.liferay.portlet.PortletPreferencesImpl;
95 import com.liferay.portlet.PortletPreferencesWrapper;
96 import com.liferay.portlet.PortletRequestImpl;
97 import com.liferay.portlet.PortletResponseImpl;
98 import com.liferay.portlet.PortletURLImpl;
99 import com.liferay.portlet.RenderRequestImpl;
100 import com.liferay.portlet.RenderResponseImpl;
101 import com.liferay.portlet.UserAttributes;
102 import com.liferay.portlet.blogs.model.BlogsEntry;
103 import com.liferay.portlet.bookmarks.model.BookmarksEntry;
104 import com.liferay.portlet.documentlibrary.model.DLFileEntry;
105 import com.liferay.portlet.imagegallery.model.IGImage;
106 import com.liferay.portlet.messageboards.model.MBMessage;
107 import com.liferay.portlet.social.util.FacebookUtil;
108 import com.liferay.portlet.wiki.model.WikiPage;
109 import com.liferay.util.Encryptor;
110 import com.liferay.util.JS;
111 import com.liferay.util.WebDirDetector;
112 import com.liferay.util.servlet.DynamicServletRequest;
113
114 import java.io.IOException;
115
116 import java.net.InetAddress;
117 import java.net.UnknownHostException;
118
119 import java.rmi.RemoteException;
120
121 import java.util.Arrays;
122 import java.util.Calendar;
123 import java.util.Date;
124 import java.util.Enumeration;
125 import java.util.HashMap;
126 import java.util.HashSet;
127 import java.util.Iterator;
128 import java.util.List;
129 import java.util.Locale;
130 import java.util.Map;
131 import java.util.Properties;
132 import java.util.ResourceBundle;
133 import java.util.Set;
134 import java.util.TimeZone;
135 import java.util.concurrent.ConcurrentHashMap;
136
137 import javax.portlet.ActionRequest;
138 import javax.portlet.ActionResponse;
139 import javax.portlet.PortletConfig;
140 import javax.portlet.PortletMode;
141 import javax.portlet.PortletPreferences;
142 import javax.portlet.PortletRequest;
143 import javax.portlet.PortletResponse;
144 import javax.portlet.PortletURL;
145 import javax.portlet.PreferencesValidator;
146 import javax.portlet.RenderRequest;
147 import javax.portlet.ValidatorException;
148 import javax.portlet.WindowState;
149 import javax.portlet.filter.PortletRequestWrapper;
150 import javax.portlet.filter.PortletResponseWrapper;
151
152 import javax.servlet.RequestDispatcher;
153 import javax.servlet.ServletContext;
154 import javax.servlet.ServletException;
155 import javax.servlet.http.HttpServletRequest;
156 import javax.servlet.http.HttpServletRequestWrapper;
157 import javax.servlet.http.HttpServletResponse;
158 import javax.servlet.http.HttpSession;
159
160 import org.apache.commons.logging.Log;
161 import org.apache.commons.logging.LogFactory;
162 import org.apache.struts.Globals;
163
164
173 public class PortalImpl implements Portal {
174
175 public PortalImpl() {
176
177
179 _computerName = System.getProperty("env.COMPUTERNAME");
180
181 if (Validator.isNull(_computerName)) {
182 _computerName = System.getProperty("env.HOST");
183 }
184
185 if (Validator.isNull(_computerName)) {
186 _computerName = System.getProperty("env.HOSTNAME");
187 }
188
189 if (Validator.isNull(_computerName)) {
190 try {
191 _computerName = InetAddress.getLocalHost().getHostName();
192 }
193 catch (UnknownHostException uhe) {
194 }
195 }
196
197 try {
198 _computerAddress = InetAddress.getByName(
199 _computerName).getHostAddress();
200 }
201 catch (UnknownHostException uhe) {
202 }
203
204 if (Validator.isNull(_computerAddress)) {
205 try {
206 _computerAddress = InetAddress.getLocalHost().getHostAddress();
207 }
208 catch (UnknownHostException uhe) {
209 }
210 }
211
212
214 ClassLoader classLoader = getClass().getClassLoader();
215
216 _portalLibDir = WebDirDetector.getLibDir(classLoader);
217
218 String portalLibDir = System.getProperty("liferay.lib.portal.dir");
219
220 if (portalLibDir != null) {
221 if (!portalLibDir.endsWith(StringPool.SLASH)) {
222 portalLibDir += StringPool.SLASH;
223 }
224
225 _portalLibDir = portalLibDir;
226 }
227
228 if (_log.isInfoEnabled()) {
229 _log.info("Portal lib directory " + _portalLibDir);
230 }
231
232 _portalWebDir = WebDirDetector.getRootDir(_portalLibDir);
233
234 if (_log.isDebugEnabled()) {
235 _log.debug("Portal web directory " + _portalWebDir);
236 }
237
238
240 _cdnHost = PropsUtil.get(PropsKeys.CDN_HOST);
241
242
244 _pathContext = PropsUtil.get(PropsKeys.PORTAL_CTX);
245
246 if (_pathContext.equals(StringPool.SLASH)) {
247 _pathContext = StringPool.BLANK;
248 }
249
250 _pathFriendlyURLPrivateGroup =
251 _pathContext + _PRIVATE_GROUP_SERVLET_MAPPING;
252 _pathFriendlyURLPrivateUser =
253 _pathContext + _PRIVATE_USER_SERVLET_MAPPING;
254 _pathFriendlyURLPublic = _pathContext + _PUBLIC_GROUP_SERVLET_MAPPING;
255 _pathImage = _cdnHost + _pathContext + PATH_IMAGE;
256 _pathMain = _pathContext + PATH_MAIN;
257
258
260 String customSystemGroups[] =
261 PropsUtil.getArray(PropsKeys.SYSTEM_GROUPS);
262
263 if ((customSystemGroups == null) || (customSystemGroups.length == 0)) {
264 _allSystemGroups = GroupConstants.SYSTEM_GROUPS;
265 }
266 else {
267 _allSystemGroups = ArrayUtil.append(
268 GroupConstants.SYSTEM_GROUPS, customSystemGroups);
269 }
270
271 _sortedSystemGroups = new String[_allSystemGroups.length];
272
273 System.arraycopy(
274 _allSystemGroups, 0, _sortedSystemGroups, 0,
275 _allSystemGroups.length);
276
277 Arrays.sort(_sortedSystemGroups, new StringComparator());
278
279
281 String customSystemRoles[] = PropsUtil.getArray(PropsKeys.SYSTEM_ROLES);
282
283 if ((customSystemRoles == null) || (customSystemRoles.length == 0)) {
284 _allSystemRoles = RoleConstants.SYSTEM_ROLES;
285 }
286 else {
287 _allSystemRoles = ArrayUtil.append(
288 RoleConstants.SYSTEM_ROLES, customSystemRoles);
289 }
290
291 _sortedSystemRoles = new String[_allSystemRoles.length];
292
293 System.arraycopy(
294 _allSystemRoles, 0, _sortedSystemRoles, 0, _allSystemRoles.length);
295
296 Arrays.sort(_sortedSystemRoles, new StringComparator());
297
298
300 String customSystemCommunityRoles[] =
301 PropsUtil.getArray(PropsKeys.SYSTEM_COMMUNITY_ROLES);
302
303 if ((customSystemCommunityRoles == null) ||
304 (customSystemCommunityRoles.length == 0)) {
305
306 _allSystemCommunityRoles = RoleConstants.SYSTEM_COMMUNITY_ROLES;
307 }
308 else {
309 _allSystemCommunityRoles = ArrayUtil.append(
310 RoleConstants.SYSTEM_COMMUNITY_ROLES,
311 customSystemCommunityRoles);
312 }
313
314 _sortedSystemCommunityRoles =
315 new String[_allSystemCommunityRoles.length];
316
317 System.arraycopy(
318 _allSystemCommunityRoles, 0, _sortedSystemCommunityRoles, 0,
319 _allSystemCommunityRoles.length);
320
321 Arrays.sort(_sortedSystemCommunityRoles, new StringComparator());
322
323
325 String customSystemOrganizationRoles[] =
326 PropsUtil.getArray(PropsKeys.SYSTEM_ORGANIZATION_ROLES);
327
328 if ((customSystemOrganizationRoles == null) ||
329 (customSystemOrganizationRoles.length == 0)) {
330
331 _allSystemOrganizationRoles =
332 RoleConstants.SYSTEM_ORGANIZATION_ROLES;
333 }
334 else {
335 _allSystemOrganizationRoles = ArrayUtil.append(
336 RoleConstants.SYSTEM_ORGANIZATION_ROLES,
337 customSystemOrganizationRoles);
338 }
339
340 _sortedSystemOrganizationRoles =
341 new String[_allSystemOrganizationRoles.length];
342
343 System.arraycopy(
344 _allSystemOrganizationRoles, 0, _sortedSystemOrganizationRoles, 0,
345 _allSystemOrganizationRoles.length);
346
347 Arrays.sort(_sortedSystemOrganizationRoles, new StringComparator());
348
349
351 _reservedParams = new HashSet<String>();
352
353 _reservedParams.add("p_l_id");
354 _reservedParams.add("p_l_reset");
355 _reservedParams.add("p_p_id");
356 _reservedParams.add("p_p_lifecycle");
357 _reservedParams.add("p_p_url_type");
358 _reservedParams.add("p_p_state");
359 _reservedParams.add("p_p_mode");
360 _reservedParams.add("p_p_resource_id");
361 _reservedParams.add("p_p_cacheability");
362 _reservedParams.add("p_p_width");
363 _reservedParams.add("p_p_col_id");
364 _reservedParams.add("p_p_col_pos");
365 _reservedParams.add("p_p_col_count");
366 _reservedParams.add("p_p_static");
367 _reservedParams.add("saveLastPath");
368 }
369
370 public void clearRequestParameters(RenderRequest renderRequest) {
371
372
374 ThemeDisplay themeDisplay = (ThemeDisplay)renderRequest.getAttribute(
375 WebKeys.THEME_DISPLAY);
376
377 if (themeDisplay.isLifecycleAction()) {
378 ((RenderRequestImpl)renderRequest).getRenderParameters().clear();
379 }
380 }
381
382 public void copyRequestParameters(
383 ActionRequest actionRequest, ActionResponse actionResponse) {
384
385 try {
386 ActionResponseImpl actionResponseImpl =
387 (ActionResponseImpl)actionResponse;
388
389 Map<String, String[]> renderParameters =
390 actionResponseImpl.getRenderParameterMap();
391
392 actionResponse.setRenderParameter("p_p_lifecycle", "1");
393
394 Enumeration<String> enu = actionRequest.getParameterNames();
395
396 while (enu.hasMoreElements()) {
397 String param = enu.nextElement();
398 String[] values = actionRequest.getParameterValues(param);
399
400 if (renderParameters.get(
401 actionResponseImpl.getNamespace() + param) == null) {
402
403 actionResponse.setRenderParameter(param, values);
404 }
405 }
406 }
407 catch (IllegalStateException ise) {
408
409
412 }
413 }
414
415 public String getCDNHost() {
416 return _cdnHost;
417 }
418
419 public String getClassName(long classNameId) {
420 try {
421 ClassName className = ClassNameServiceUtil.getClassName(
422 classNameId);
423
424 return className.getValue();
425 }
426 catch (Exception e) {
427 throw new RuntimeException(
428 "Unable to get class name from id " + classNameId);
429 }
430 }
431
432 public long getClassNameId(Class<?> classObj) {
433 return getClassNameId(classObj.getName());
434 }
435
436 public long getClassNameId(String value) {
437 try {
438 ClassName className = ClassNameServiceUtil.getClassName(value);
439
440 return className.getClassNameId();
441 }
442 catch (Exception e) {
443 throw new RuntimeException(
444 "Unable to get class name from value " + value, e);
445 }
446 }
447
448 public String getClassNamePortletId(String className) {
449 String portletId = StringPool.BLANK;
450
451 if (className.startsWith("com.liferay.portlet.blogs")) {
452 portletId = PortletKeys.BLOGS;
453 }
454 else if (className.startsWith("com.liferay.portlet.bookmarks")) {
455 portletId = PortletKeys.BOOKMARKS;
456 }
457 else if (className.startsWith("com.liferay.portlet.documentlibrary")) {
458 portletId = PortletKeys.DOCUMENT_LIBRARY;
459 }
460 else if (className.startsWith("com.liferay.portlet.imagegallery")) {
461 portletId = PortletKeys.IMAGE_GALLERY;
462 }
463 else if (className.startsWith("com.liferay.portlet.journal")) {
464 portletId = PortletKeys.JOURNAL;
465 }
466 else if (className.startsWith("com.liferay.portlet.messageboards")) {
467 portletId = PortletKeys.MESSAGE_BOARDS;
468 }
469 else if (className.startsWith("com.liferay.portlet.wiki")) {
470 portletId = PortletKeys.WIKI;
471 }
472
473 return portletId;
474 }
475
476 public String getCommunityLoginURL(ThemeDisplay themeDisplay)
477 throws PortalException, SystemException {
478
479 if (Validator.isNull(PropsValues.AUTH_LOGIN_COMMUNITY_URL)) {
480 return null;
481 }
482
483 for (Layout layout : themeDisplay.getLayouts()) {
484 if (layout.getFriendlyURL().equals(
485 PropsValues.AUTH_LOGIN_COMMUNITY_URL)) {
486
487 if (themeDisplay.getLayout() != null) {
488 String layoutSetFriendlyURL = getLayoutSetFriendlyURL(
489 themeDisplay.getLayout().getLayoutSet(), themeDisplay);
490
491 return layoutSetFriendlyURL +
492 PropsValues.AUTH_LOGIN_COMMUNITY_URL;
493 }
494
495 break;
496 }
497 }
498
499 return null;
500 }
501
502 public Company getCompany(HttpServletRequest request)
503 throws PortalException, SystemException {
504
505 long companyId = getCompanyId(request);
506
507 if (companyId <= 0) {
508 return null;
509 }
510
511 Company company = (Company)request.getAttribute(WebKeys.COMPANY);
512
513 if (company == null) {
514
515
517 try {
518 company = CompanyLocalServiceUtil.getCompanyById(companyId);
519 }
520 catch (NoSuchCompanyException nsce) {
521 company = CompanyLocalServiceUtil.getCompanyById(
522 PortalInstances.getDefaultCompanyId());
523 }
524
525 request.setAttribute(WebKeys.COMPANY, company);
526 }
527
528 return company;
529 }
530
531 public Company getCompany(PortletRequest portletRequest)
532 throws PortalException, SystemException {
533
534 return getCompany(getHttpServletRequest(portletRequest));
535 }
536
537 public long getCompanyId(HttpServletRequest request) {
538 return PortalInstances.getCompanyId(request);
539 }
540
541 public long getCompanyId(PortletRequest portletRequest) {
542 return getCompanyId(getHttpServletRequest(portletRequest));
543 }
544
545 public long getCompanyIdByWebId(ServletContext servletContext) {
546 String webId = GetterUtil.getString(
547 servletContext.getInitParameter("company_web_id"));
548
549 return getCompanyIdByWebId(webId);
550 }
551
552 public long getCompanyIdByWebId(String webId) {
553 long companyId = 0;
554
555 try {
556 Company company = CompanyLocalServiceUtil.getCompanyByWebId(webId);
557
558 companyId = company.getCompanyId();
559 }
560 catch (Exception e) {
561 _log.error(e.getMessage());
562 }
563
564 return companyId;
565 }
566
567 public long[] getCompanyIds() {
568 return PortalInstances.getCompanyIds();
569 }
570
571 public String getComputerAddress() {
572 return _computerAddress;
573 }
574
575 public String getComputerName() {
576 return _computerName;
577 }
578
579 public String getCurrentURL(HttpServletRequest request) {
580 String currentURL = (String)request.getAttribute(WebKeys.CURRENT_URL);
581
582 if (currentURL == null) {
583 currentURL = ParamUtil.getString(request, "currentURL");
584
585 if (Validator.isNull(currentURL)) {
586 if (true) {
587 currentURL = HttpUtil.getCompleteURL(request);
588 }
589 else {
590
591
593 currentURL = _getCurrentURL(request);
594 }
595
596 if ((Validator.isNotNull(currentURL)) &&
597 (currentURL.indexOf("j_security_check") == -1)) {
598
599 currentURL = currentURL.substring(
600 currentURL.indexOf("://") + 3, currentURL.length());
601
602 currentURL = currentURL.substring(
603 currentURL.indexOf("/"), currentURL.length());
604 }
605
606 if (Validator.isNotNull(currentURL) &&
607 FacebookUtil.isFacebook(currentURL)) {
608
609 String[] facebookData = FacebookUtil.getFacebookData(
610 request);
611
612 currentURL =
613 FacebookUtil.FACEBOOK_APPS_URL + facebookData[0] +
614 facebookData[2];
615 }
616 }
617
618 if (Validator.isNull(currentURL)) {
619 currentURL = getPathMain();
620 }
621
622 request.setAttribute(WebKeys.CURRENT_URL, currentURL);
623 }
624
625 return currentURL;
626 }
627
628 public String getCurrentURL(PortletRequest portletRequest) {
629 return (String)portletRequest.getAttribute(WebKeys.CURRENT_URL);
630 }
631
632 public String getCustomSQLFunctionIsNotNull() {
633 return PropsValues.CUSTOM_SQL_FUNCTION_ISNOTNULL;
634 }
635
636 public String getCustomSQLFunctionIsNull() {
637 return PropsValues.CUSTOM_SQL_FUNCTION_ISNULL;
638 }
639
640 public Date getDate(int month, int day, int year, PortalException pe)
641 throws PortalException {
642
643 return getDate(month, day, year, null, pe);
644 }
645
646 public Date getDate(
647 int month, int day, int year, TimeZone timeZone, PortalException pe)
648 throws PortalException {
649
650 return getDate(month, day, year, -1, -1, timeZone, pe);
651 }
652
653 public Date getDate(
654 int month, int day, int year, int hour, int min, PortalException pe)
655 throws PortalException {
656
657 return getDate(month, day, year, hour, min, null, pe);
658 }
659
660 public Date getDate(
661 int month, int day, int year, int hour, int min, TimeZone timeZone,
662 PortalException pe)
663 throws PortalException {
664
665 if (!Validator.isGregorianDate(month, day, year)) {
666 throw pe;
667 }
668 else {
669 Calendar cal = null;
670
671 if (timeZone == null) {
672 cal = CalendarFactoryUtil.getCalendar();
673 }
674 else {
675 cal = CalendarFactoryUtil.getCalendar(timeZone);
676 }
677
678 if ((hour == -1) || (min == -1)) {
679 cal.set(year, month, day, 0, 0, 0);
680 }
681 else {
682 cal.set(year, month, day, hour, min, 0);
683 }
684
685 cal.set(Calendar.MILLISECOND, 0);
686
687 Date date = cal.getTime();
688
689
694
695 return date;
696 }
697 }
698
699 public long getDefaultCompanyId() {
700 return PortalInstances.getDefaultCompanyId();
701 }
702
703 public String getHost(HttpServletRequest request) {
704 request = getOriginalServletRequest(request);
705
706 String host = request.getHeader("Host");
707
708 if (host != null) {
709 host = host.trim().toLowerCase();
710
711 int pos = host.indexOf(':');
712
713 if (pos >= 0) {
714 host = host.substring(0, pos);
715 }
716 }
717 else {
718 host = null;
719 }
720
721 return host;
722 }
723
724 public String getHost(PortletRequest portletRequest) {
725 return getHost(getHttpServletRequest(portletRequest));
726 }
727
728 public HttpServletRequest getHttpServletRequest(
729 PortletRequest portletRequest) {
730
731 if (portletRequest instanceof PortletRequestImpl) {
732 PortletRequestImpl portletRequestImpl =
733 (PortletRequestImpl)portletRequest;
734
735 return portletRequestImpl.getHttpServletRequest();
736 }
737 else if (portletRequest instanceof PortletRequestWrapper) {
738 PortletRequestWrapper portletRequestWrapper =
739 (PortletRequestWrapper)portletRequest;
740
741 return getHttpServletRequest(portletRequestWrapper.getRequest());
742 }
743
744 HttpServletRequest request = HttpServletUtil.getHttpServletRequest(
745 portletRequest);
746
747 if (request != null) {
748 return request;
749 }
750
751 throw new RuntimeException(
752 "Unable to get the HTTP servlet request from " +
753 portletRequest.getClass().getName());
754 }
755
756 public HttpServletResponse getHttpServletResponse(
757 PortletResponse portletResponse) {
758
759 if (portletResponse instanceof ActionResponseImpl) {
760 ActionResponseImpl actionResponseImpl =
761 (ActionResponseImpl)portletResponse;
762
763 return actionResponseImpl.getHttpServletResponse();
764 }
765 else if (portletResponse instanceof RenderResponseImpl) {
766 RenderResponseImpl renderResponseImpl =
767 (RenderResponseImpl)portletResponse;
768
769 return renderResponseImpl.getHttpServletResponse();
770 }
771 else if (portletResponse instanceof PortletResponseWrapper) {
772 PortletResponseWrapper portletResponseWrapper =
773 (PortletResponseWrapper)portletResponse;
774
775 return getHttpServletResponse(portletResponseWrapper.getResponse());
776 }
777
778 HttpServletResponse response = HttpServletUtil.getHttpServletResponse(
779 portletResponse);
780
781 if (response != null) {
782 return response;
783 }
784
785 PortletResponseImpl portletResponseImpl =
786 PortletResponseImpl.getPortletResponseImpl(portletResponse);
787
788 return portletResponseImpl.getHttpServletResponse();
789 }
790
791 public String getLayoutEditPage(Layout layout) {
792 return PropsUtil.get(
793 PropsKeys.LAYOUT_EDIT_PAGE, new Filter(layout.getType()));
794 }
795
796 public String getLayoutViewPage(Layout layout) {
797 return PropsUtil.get(
798 PropsKeys.LAYOUT_VIEW_PAGE, new Filter(layout.getType()));
799 }
800
801 public String getLayoutURL(ThemeDisplay themeDisplay) {
802 return getLayoutURL(themeDisplay.getLayout(), themeDisplay);
803 }
804
805 public String getLayoutURL(Layout layout, ThemeDisplay themeDisplay) {
806 return getLayoutURL(layout, themeDisplay, true);
807 }
808
809 public String getLayoutURL(
810 Layout layout, ThemeDisplay themeDisplay, boolean doAsUser) {
811
812 if (layout == null) {
813 return themeDisplay.getPathMain() + PATH_PORTAL_LAYOUT;
814 }
815
816 if (!layout.getType().equals(LayoutConstants.TYPE_URL)) {
817 String layoutFriendlyURL = getLayoutFriendlyURL(
818 layout, themeDisplay);
819
820 if (Validator.isNotNull(layoutFriendlyURL)) {
821 if (doAsUser &&
822 Validator.isNotNull(themeDisplay.getDoAsUserId())) {
823
824 layoutFriendlyURL = HttpUtil.addParameter(
825 layoutFriendlyURL, "doAsUserId",
826 themeDisplay.getDoAsUserId());
827 }
828
829 return layoutFriendlyURL;
830 }
831 }
832
833 String layoutURL = getLayoutActualURL(layout);
834
835 if (doAsUser && Validator.isNotNull(themeDisplay.getDoAsUserId())) {
836 layoutURL = HttpUtil.addParameter(
837 layoutURL, "doAsUserId", themeDisplay.getDoAsUserId());
838 }
839
840 return layoutURL;
841 }
842
843 public String getLayoutActualURL(Layout layout) {
844 return getLayoutActualURL(layout, getPathMain());
845 }
846
847 public String getLayoutActualURL(Layout layout, String mainPath) {
848 Map<String, String> variables = new HashMap<String, String>();
849
850 variables.put("liferay:groupId", String.valueOf(layout.getGroupId()));
851 variables.put("liferay:mainPath", mainPath);
852 variables.put("liferay:plid", String.valueOf(layout.getPlid()));
853
854 UnicodeProperties typeSettingsProperties =
855 layout.getLayoutType().getTypeSettingsProperties();
856
857 Iterator<Map.Entry<String, String>> itr =
858 typeSettingsProperties.entrySet().iterator();
859
860 while (itr.hasNext()) {
861 Map.Entry<String, String> entry = itr.next();
862
863 String key = entry.getKey();
864 String value = entry.getValue();
865
866 variables.put(key, value);
867 }
868
869 String href = PropsUtil.get(
870 PropsKeys.LAYOUT_URL, new Filter(layout.getType(), variables));
871
872 return href;
873 }
874
875 public String getLayoutActualURL(
876 long groupId, boolean privateLayout, String mainPath,
877 String friendlyURL)
878 throws PortalException, SystemException {
879
880 return getLayoutActualURL(
881 groupId, privateLayout, mainPath, friendlyURL, null);
882 }
883
884 public String getLayoutActualURL(
885 long groupId, boolean privateLayout, String mainPath,
886 String friendlyURL, Map<String, String[]> params)
887 throws PortalException, SystemException {
888
889 Layout layout = null;
890 String queryString = StringPool.BLANK;
891
892 if (Validator.isNull(friendlyURL)) {
893 List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
894 groupId, privateLayout,
895 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID);
896
897 if (layouts.size() > 0) {
898 layout = layouts.get(0);
899 }
900 else {
901 throw new NoSuchLayoutException(
902 "{groupId=" + groupId + ",privateLayout=" + privateLayout +
903 "} does not have any layouts");
904 }
905 }
906 else {
907 Object[] friendlyURLMapper = getPortletFriendlyURLMapper(
908 groupId, privateLayout, friendlyURL, params);
909
910 layout = (Layout)friendlyURLMapper[0];
911 queryString = (String)friendlyURLMapper[1];
912 }
913
914 String layoutActualURL = getLayoutActualURL(layout, mainPath);
915
916 if (Validator.isNotNull(queryString)) {
917 layoutActualURL = layoutActualURL + queryString;
918 }
919
920 return layoutActualURL;
921 }
922
923 public String getLayoutFriendlyURL(
924 Layout layout, ThemeDisplay themeDisplay) {
925
926 if (!isLayoutFriendliable(layout)) {
927 return null;
928 }
929
930 String layoutFriendlyURL = layout.getFriendlyURL();
931
932 LayoutSet layoutSet = layout.getLayoutSet();
933
934 long curLayoutSetId =
935 themeDisplay.getLayout().getLayoutSet().getLayoutSetId();
936
937 String portalURL = StringPool.BLANK;
938
939 if (Validator.isNotNull(layoutSet.getVirtualHost())) {
940 portalURL = getPortalURL(
941 layoutSet.getVirtualHost(), themeDisplay.getServerPort(),
942 themeDisplay.isSecure());
943
944 if ((layoutSet.getLayoutSetId() != curLayoutSetId) ||
945 (portalURL.startsWith(themeDisplay.getPortalURL()))) {
946
947 if (themeDisplay.isWidget()) {
948 layoutFriendlyURL =
949 PropsValues.WIDGET_SERVLET_MAPPING + layoutFriendlyURL;
950 }
951
952 if (themeDisplay.isI18n()) {
953 layoutFriendlyURL =
954 StringPool.SLASH + themeDisplay.getI18nLanguageId() +
955 layoutFriendlyURL;
956 }
957
958 return portalURL + _pathContext + layoutFriendlyURL;
959 }
960 }
961 else {
962 if ((layoutSet.getLayoutSetId() != curLayoutSetId) &&
963 (layout.getGroup().getClassPK() != themeDisplay.getUserId())) {
964
965 String virtualHost = themeDisplay.getCompany().getVirtualHost();
966
967 if (!virtualHost.equalsIgnoreCase(_LOCALHOST)) {
968 portalURL = getPortalURL(
969 virtualHost, themeDisplay.getServerPort(),
970 themeDisplay.isSecure());
971 }
972 }
973 }
974
975 Group group = layout.getGroup();
976
977 String friendlyURL = null;
978
979 if (layout.isPrivateLayout()) {
980 if (group.isUser()) {
981 friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
982 }
983 else {
984 friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
985 }
986 }
987 else {
988 friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
989 }
990
991 if (themeDisplay.isWidget()) {
992 friendlyURL = PropsValues.WIDGET_SERVLET_MAPPING + friendlyURL;
993 }
994
995 if (themeDisplay.isI18n()) {
996 friendlyURL =
997 StringPool.SLASH + themeDisplay.getI18nLanguageId() +
998 friendlyURL;
999 }
1000
1001 return portalURL + _pathContext + friendlyURL + group.getFriendlyURL() +
1002 layoutFriendlyURL;
1003 }
1004
1005 public String getLayoutSetFriendlyURL(
1006 LayoutSet layoutSet, ThemeDisplay themeDisplay)
1007 throws PortalException, SystemException {
1008
1009 if (Validator.isNotNull(layoutSet.getVirtualHost())) {
1010 String portalURL = getPortalURL(
1011 layoutSet.getVirtualHost(), themeDisplay.getServerPort(),
1012 themeDisplay.isSecure());
1013
1014
1017 long curLayoutSetId =
1018 themeDisplay.getLayout().getLayoutSet().getLayoutSetId();
1019
1020 if ((layoutSet.getLayoutSetId() != curLayoutSetId) ||
1021 (portalURL.startsWith(themeDisplay.getURLPortal()))) {
1022
1023 String layoutSetFriendlyURL = StringPool.BLANK;
1024
1025 if (themeDisplay.isI18n()) {
1026 layoutSetFriendlyURL =
1027 StringPool.SLASH + themeDisplay.getI18nLanguageId();
1028 }
1029
1030 return portalURL + _pathContext + layoutSetFriendlyURL;
1031 }
1032 }
1033
1034 Group group = GroupLocalServiceUtil.getGroup(layoutSet.getGroupId());
1035
1036 String friendlyURL = null;
1037
1038 if (layoutSet.isPrivateLayout()) {
1039 if (group.isUser()) {
1040 friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
1041 }
1042 else {
1043 friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
1044 }
1045 }
1046 else {
1047 friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
1048 }
1049
1050 if (themeDisplay.isI18n()) {
1051 friendlyURL =
1052 StringPool.SLASH + themeDisplay.getI18nLanguageId() +
1053 friendlyURL;
1054 }
1055
1056 return _pathContext + friendlyURL + group.getFriendlyURL();
1057 }
1058
1059 public String getLayoutTarget(Layout layout) {
1060 UnicodeProperties typeSettingsProps =
1061 layout.getTypeSettingsProperties();
1062
1063 String target = typeSettingsProps.getProperty("target");
1064
1065 if (Validator.isNull(target)) {
1066 target = StringPool.BLANK;
1067 }
1068 else {
1069 target = "target=\"" + target + "\"";
1070 }
1071
1072 return target;
1073 }
1074
1075 public String getJsSafePortletId(String portletId) {
1076 return JS.getSafeName(portletId);
1077 }
1078
1079 public Locale getLocale(HttpServletRequest request) {
1080 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
1081 WebKeys.THEME_DISPLAY);
1082
1083 if (themeDisplay != null) {
1084 return themeDisplay.getLocale();
1085 }
1086 else {
1087 HttpSession session = request.getSession();
1088
1089 return (Locale)session.getAttribute(Globals.LOCALE_KEY);
1090 }
1091 }
1092
1093 public Locale getLocale(RenderRequest renderRequest) {
1094 return getLocale(getHttpServletRequest(renderRequest));
1095 }
1096
1097 public HttpServletRequest getOriginalServletRequest(
1098 HttpServletRequest request) {
1099
1100 HttpServletRequest originalRequest = request;
1101
1102 while (originalRequest.getClass().getName().startsWith(
1103 "com.liferay.")) {
1104
1105
1108 originalRequest = (HttpServletRequest)
1109 ((HttpServletRequestWrapper)originalRequest).getRequest();
1110 }
1111
1112 return originalRequest;
1113 }
1114
1115 public String getPathContext() {
1116 return _pathContext;
1117 }
1118
1119 public String getPathFriendlyURLPrivateGroup() {
1120 return _pathFriendlyURLPrivateGroup;
1121 }
1122
1123 public String getPathFriendlyURLPrivateUser() {
1124 return _pathFriendlyURLPrivateUser;
1125 }
1126
1127 public String getPathFriendlyURLPublic() {
1128 return _pathFriendlyURLPublic;
1129 }
1130
1131 public String getPathImage() {
1132 return _pathImage;
1133 }
1134
1135 public String getPathMain() {
1136 return _pathMain;
1137 }
1138
1139 public long getPlidFromFriendlyURL(long companyId, String friendlyURL) {
1140 if (Validator.isNull(friendlyURL)) {
1141 return LayoutConstants.DEFAULT_PLID;
1142 }
1143
1144 String[] urlParts = friendlyURL.split("\\/", 4);
1145
1146 if ((friendlyURL.charAt(0) != CharPool.SLASH) &&
1147 (urlParts.length != 4)) {
1148
1149 return LayoutConstants.DEFAULT_PLID;
1150 }
1151
1152 boolean privateLayout = true;
1153
1154 String urlPrefix = StringPool.SLASH + urlParts[1];
1155
1156 if (_PUBLIC_GROUP_SERVLET_MAPPING.equals(urlPrefix)) {
1157 privateLayout = false;
1158 }
1159 else if (_PRIVATE_GROUP_SERVLET_MAPPING.equals(urlPrefix) ||
1160 _PRIVATE_USER_SERVLET_MAPPING.equals(urlPrefix)) {
1161
1162 privateLayout = true;
1163 }
1164 else {
1165 return LayoutConstants.DEFAULT_PLID;
1166 }
1167
1168 Group group = null;
1169
1170 try {
1171 group = GroupLocalServiceUtil.getFriendlyURLGroup(
1172 companyId, StringPool.SLASH + urlParts[2]);
1173 }
1174 catch (Exception e) {
1175 }
1176
1177 if (group != null) {
1178 Layout layout = null;
1179
1180 try {
1181 layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
1182 group.getGroupId(), privateLayout,
1183 StringPool.SLASH + urlParts[3]);
1184
1185 return layout.getPlid();
1186 }
1187 catch (Exception e) {
1188 }
1189 }
1190
1191 return LayoutConstants.DEFAULT_PLID;
1192 }
1193
1194 public long getPlidFromPortletId(
1195 long groupId, boolean privateLayout, String portletId) {
1196
1197 long plid = LayoutConstants.DEFAULT_PLID;
1198
1199 StringBuilder sb = new StringBuilder();
1200
1201 sb.append(groupId);
1202 sb.append(StringPool.SPACE);
1203 sb.append(privateLayout);
1204 sb.append(StringPool.SPACE);
1205 sb.append(portletId);
1206
1207 String key = sb.toString();
1208
1209 Long plidObj = _plidToPortletIdCache.get(key);
1210
1211 if (plidObj == null) {
1212 plid = _getPlidFromPortletId(groupId, privateLayout, portletId);
1213
1214 if (plid != LayoutConstants.DEFAULT_PLID) {
1215 _plidToPortletIdCache.put(key, plid);
1216 }
1217 }
1218 else {
1219 plid = plidObj.longValue();
1220
1221 boolean validPlid = false;
1222
1223 try {
1224 Layout layout = LayoutLocalServiceUtil.getLayout(plid);
1225
1226 LayoutTypePortlet layoutTypePortlet =
1227 (LayoutTypePortlet)layout.getLayoutType();
1228
1229 if (layoutTypePortlet.hasPortletId(portletId)) {
1230 validPlid = true;
1231 }
1232 }
1233 catch (Exception e) {
1234 }
1235
1236 if (!validPlid) {
1237 _plidToPortletIdCache.remove(key);
1238
1239 plid = _getPlidFromPortletId(groupId, privateLayout, portletId);
1240
1241 if (plid != LayoutConstants.DEFAULT_PLID) {
1242 _plidToPortletIdCache.put(key, plid);
1243 }
1244 }
1245 }
1246
1247 return plid;
1248 }
1249
1250 public String getPortalLibDir() {
1251 return _portalLibDir;
1252 }
1253
1254 public int getPortalPort() {
1255 return _portalPort.intValue();
1256 }
1257
1258 public Properties getPortalProperties() {
1259 return PropsUtil.getProperties();
1260 }
1261
1262 public String getPortalURL(ThemeDisplay themeDisplay) {
1263 String serverName = themeDisplay.getServerName();
1264
1265 Layout layout = themeDisplay.getLayout();
1266
1267 if (layout != null) {
1268 LayoutSet layoutSet = layout.getLayoutSet();
1269
1270 if (Validator.isNotNull(layoutSet.getVirtualHost())) {
1271 serverName = layoutSet.getVirtualHost();
1272 }
1273 }
1274
1275 return getPortalURL(
1276 serverName, themeDisplay.getServerPort(), themeDisplay.isSecure());
1277 }
1278
1279 public String getPortalURL(HttpServletRequest request) {
1280 return getPortalURL(request, request.isSecure());
1281 }
1282
1283 public String getPortalURL(HttpServletRequest request, boolean secure) {
1284 return getPortalURL(
1285 request.getServerName(), request.getServerPort(), secure);
1286 }
1287
1288 public String getPortalURL(PortletRequest portletRequest) {
1289 return getPortalURL(portletRequest, portletRequest.isSecure());
1290 }
1291
1292 public String getPortalURL(PortletRequest portletRequest, boolean secure) {
1293 return getPortalURL(
1294 portletRequest.getServerName(), portletRequest.getServerPort(),
1295 secure);
1296 }
1297
1298 public String getPortalURL(
1299 String serverName, int serverPort, boolean secure) {
1300
1301 StringBuilder sb = new StringBuilder();
1302
1303 if (secure || Http.HTTPS.equals(PropsValues.WEB_SERVER_PROTOCOL)) {
1304 sb.append(Http.HTTPS_WITH_SLASH);
1305 }
1306 else {
1307 sb.append(Http.HTTP_WITH_SLASH);
1308 }
1309
1310 if (Validator.isNull(PropsValues.WEB_SERVER_HOST)) {
1311 sb.append(serverName);
1312 }
1313 else {
1314 sb.append(PropsValues.WEB_SERVER_HOST);
1315 }
1316
1317 if (!secure) {
1318 if (PropsValues.WEB_SERVER_HTTP_PORT == -1) {
1319 if ((serverPort != Http.HTTP_PORT) &&
1320 (serverPort != Http.HTTPS_PORT)) {
1321
1322 sb.append(StringPool.COLON);
1323 sb.append(serverPort);
1324 }
1325 }
1326 else {
1327 if ((PropsValues.WEB_SERVER_HTTP_PORT != serverPort) &&
1328 (PropsValues.WEB_SERVER_HTTP_PORT != Http.HTTP_PORT)) {
1329
1330 sb.append(StringPool.COLON);
1331 sb.append(PropsValues.WEB_SERVER_HTTP_PORT);
1332 }
1333 }
1334 }
1335
1336 if (secure) {
1337 if (PropsValues.WEB_SERVER_HTTPS_PORT == -1) {
1338 if ((serverPort != Http.HTTP_PORT) &&
1339 (serverPort != Http.HTTPS_PORT)) {
1340
1341 sb.append(StringPool.COLON);
1342 sb.append(serverPort);
1343 }
1344 }
1345 else {
1346 if ((PropsValues.WEB_SERVER_HTTPS_PORT != serverPort) &&
1347 (PropsValues.WEB_SERVER_HTTPS_PORT != Http.HTTPS_PORT)) {
1348
1349 sb.append(StringPool.COLON);
1350 sb.append(PropsValues.WEB_SERVER_HTTPS_PORT);
1351 }
1352 }
1353 }
1354
1355 return sb.toString();
1356 }
1357
1358 public String getPortalWebDir() {
1359 return _portalWebDir;
1360 }
1361
1362 public Object[] getPortletFriendlyURLMapper(
1363 long groupId, boolean privateLayout, String url)
1364 throws PortalException, SystemException {
1365
1366 return getPortletFriendlyURLMapper(groupId, privateLayout, url, null);
1367 }
1368
1369 public Object[] getPortletFriendlyURLMapper(
1370 long groupId, boolean privateLayout, String url,
1371 Map<String, String[]> params)
1372 throws PortalException, SystemException {
1373
1374 boolean foundFriendlyURLMapper = false;
1375
1376 String friendlyURL = url;
1377 String queryString = StringPool.BLANK;
1378
1379 List<FriendlyURLMapper> friendlyURLMappers =
1380 PortletLocalServiceUtil.getFriendlyURLMappers();
1381
1382 Iterator<FriendlyURLMapper> itr = friendlyURLMappers.iterator();
1383
1384 while (itr.hasNext()) {
1385 FriendlyURLMapper friendlyURLMapper = itr.next();
1386
1387 if (url.endsWith(
1388 StringPool.SLASH + friendlyURLMapper.getMapping())) {
1389
1390 url += StringPool.SLASH;
1391 }
1392
1393 int pos = -1;
1394
1395 if (friendlyURLMapper.isCheckMappingWithPrefix()) {
1396 pos = url.indexOf(
1397 "/-/" + friendlyURLMapper.getMapping() + StringPool.SLASH);
1398 }
1399 else {
1400 pos = url.indexOf(
1401 StringPool.SLASH + friendlyURLMapper.getMapping() +
1402 StringPool.SLASH);
1403 }
1404
1405 if (pos != -1) {
1406 foundFriendlyURLMapper = true;
1407
1408 friendlyURL = url.substring(0, pos);
1409
1410 Map<String, String[]> actualParams = null;
1411
1412 if (params != null) {
1413 actualParams = new HashMap<String, String[]>(params);
1414 }
1415 else {
1416 actualParams = new HashMap<String, String[]>();
1417 }
1418
1419
1433
1434 if (friendlyURLMapper.isCheckMappingWithPrefix()) {
1435 friendlyURLMapper.populateParams(
1436 url.substring(pos + 2), actualParams);
1437 }
1438 else {
1439 friendlyURLMapper.populateParams(
1440 url.substring(pos), actualParams);
1441 }
1442
1443 queryString =
1444 StringPool.AMPERSAND +
1445 HttpUtil.parameterMapToString(actualParams, false);
1446
1447 break;
1448 }
1449 }
1450
1451 if (!foundFriendlyURLMapper) {
1452 int x = url.indexOf("/-/");
1453
1454 if (x != -1) {
1455 int y = url.indexOf(StringPool.SLASH, x + 3);
1456
1457 if (y == -1) {
1458 y = url.length();
1459 }
1460
1461 String ppid = url.substring(x + 3, y);
1462
1463 if (Validator.isNotNull(ppid)) {
1464 friendlyURL = url.substring(0, x);
1465
1466 Map<String, String[]> actualParams = null;
1467
1468 if (params != null) {
1469 actualParams = new HashMap<String, String[]>(params);
1470 }
1471 else {
1472 actualParams = new HashMap<String, String[]>();
1473 }
1474
1475 actualParams.put("p_p_id", new String[] {ppid});
1476 actualParams.put("p_p_lifecycle", new String[] {"0"});
1477 actualParams.put(
1478 "p_p_state",
1479 new String[] {WindowState.MAXIMIZED.toString()});
1480 actualParams.put(
1481 "p_p_mode", new String[] {PortletMode.VIEW.toString()});
1482
1483 queryString =
1484 StringPool.AMPERSAND +
1485 HttpUtil.parameterMapToString(actualParams, false);
1486 }
1487 }
1488 }
1489
1490 friendlyURL = StringUtil.replace(
1491 friendlyURL, StringPool.DOUBLE_SLASH, StringPool.SLASH);
1492
1493 if (friendlyURL.endsWith(StringPool.SLASH)) {
1494 friendlyURL = friendlyURL.substring(0, friendlyURL.length() - 1);
1495 }
1496
1497 Layout layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
1498 groupId, privateLayout, friendlyURL);
1499
1500 return new Object[] {layout, queryString};
1501 }
1502
1503
1506 public long getPortletGroupId(long plid) {
1507 Layout layout = null;
1508
1509 try {
1510 layout = LayoutLocalServiceUtil.getLayout(plid);
1511 }
1512 catch (Exception e) {
1513 }
1514
1515 return getPortletGroupId(layout);
1516 }
1517
1518
1521 public long getPortletGroupId(Layout layout) {
1522 return getScopeGroupId(layout);
1523 }
1524
1525
1528 public long getPortletGroupId(HttpServletRequest request) {
1529 return getScopeGroupId(request);
1530 }
1531
1532
1535 public long getPortletGroupId(ActionRequest actionRequest) {
1536 return getScopeGroupId(actionRequest);
1537 }
1538
1539
1542 public long getPortletGroupId(RenderRequest renderRequest) {
1543 return getScopeGroupId(renderRequest);
1544 }
1545
1546 public String getPortletId(HttpServletRequest request) {
1547 PortletConfigImpl configImpl = (PortletConfigImpl)request.getAttribute(
1548 JavaConstants.JAVAX_PORTLET_CONFIG);
1549
1550 return configImpl.getPortletId();
1551 }
1552
1553 public String getPortletId(PortletRequest portletRequest) {
1554 PortletConfigImpl portletConfigImpl =
1555 (PortletConfigImpl)portletRequest.getAttribute(
1556 JavaConstants.JAVAX_PORTLET_CONFIG);
1557
1558 return portletConfigImpl.getPortletId();
1559 }
1560
1561 public String getPortletNamespace(String portletId) {
1562 StringBuilder sb = new StringBuilder();
1563
1564 sb.append(StringPool.UNDERLINE);
1565 sb.append(portletId);
1566 sb.append(StringPool.UNDERLINE);
1567
1568 return sb.toString();
1569 }
1570
1571 public String getPortletTitle(
1572 String portletId, long companyId, String languageId) {
1573
1574 Locale locale = LocaleUtil.fromLanguageId(languageId);
1575
1576 return getPortletTitle(portletId, companyId, locale);
1577 }
1578
1579 public String getPortletTitle(
1580 String portletId, long companyId, Locale locale) {
1581
1582 StringBuilder sb = new StringBuilder();
1583
1584 sb.append(JavaConstants.JAVAX_PORTLET_TITLE);
1585 sb.append(StringPool.PERIOD);
1586 sb.append(portletId);
1587
1588 return LanguageUtil.get(companyId, locale, sb.toString());
1589 }
1590
1591 public String getPortletTitle(String portletId, User user) {
1592 StringBuilder sb = new StringBuilder();
1593
1594 sb.append(JavaConstants.JAVAX_PORTLET_TITLE);
1595 sb.append(StringPool.PERIOD);
1596 sb.append(portletId);
1597
1598 return LanguageUtil.get(
1599 user.getCompanyId(), user.getLocale(), sb.toString());
1600 }
1601
1602 public String getPortletTitle(
1603 Portlet portlet, long companyId, String languageId) {
1604
1605 return getPortletTitle(portlet.getPortletId(), companyId, languageId);
1606 }
1607
1608 public String getPortletTitle(
1609 Portlet portlet, long companyId, Locale locale) {
1610
1611 return getPortletTitle(portlet.getPortletId(), companyId, locale);
1612 }
1613
1614 public String getPortletTitle(Portlet portlet, User user) {
1615 return getPortletTitle(portlet.getPortletId(), user);
1616 }
1617
1618 public String getPortletTitle(
1619 Portlet portlet, ServletContext servletContext, Locale locale) {
1620
1621 PortletConfig portletConfig = PortletConfigFactory.create(
1622 portlet, servletContext);
1623
1624 ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
1625
1626 return resourceBundle.getString(JavaConstants.JAVAX_PORTLET_TITLE);
1627 }
1628
1629 public String getPortletXmlFileName() throws SystemException {
1630 if (PrefsPropsUtil.getBoolean(
1631 PropsKeys.AUTO_DEPLOY_CUSTOM_PORTLET_XML,
1632 PropsValues.AUTO_DEPLOY_CUSTOM_PORTLET_XML)) {
1633
1634 return PORTLET_XML_FILE_NAME_CUSTOM;
1635 }
1636 else {
1637 return PORTLET_XML_FILE_NAME_STANDARD;
1638 }
1639 }
1640
1641 public PortletPreferences getPreferences(HttpServletRequest request) {
1642 RenderRequest renderRequest = (RenderRequest)request.getAttribute(
1643 JavaConstants.JAVAX_PORTLET_REQUEST);
1644
1645 PortletPreferences prefs = null;
1646
1647 if (renderRequest != null) {
1648 PortletPreferencesWrapper prefsWrapper =
1649 (PortletPreferencesWrapper)renderRequest.getPreferences();
1650
1651 prefs = prefsWrapper.getPreferencesImpl();
1652 }
1653
1654 return prefs;
1655 }
1656
1657 public PreferencesValidator getPreferencesValidator(Portlet portlet) {
1658 PortletApp portletApp = portlet.getPortletApp();
1659
1660 if (portletApp.isWARFile()) {
1661 PortletBag portletBag = PortletBagPool.get(
1662 portlet.getRootPortletId());
1663
1664 return portletBag.getPreferencesValidatorInstance();
1665 }
1666 else {
1667 PreferencesValidator prefsValidator = null;
1668
1669 if (Validator.isNotNull(portlet.getPreferencesValidator())) {
1670 prefsValidator =
1671 (PreferencesValidator)InstancePool.get(
1672 portlet.getPreferencesValidator());
1673 }
1674
1675 return prefsValidator;
1676 }
1677 }
1678
1679 public long getScopeGroupId(long plid) {
1680 Layout layout = null;
1681
1682 try {
1683 layout = LayoutLocalServiceUtil.getLayout(plid);
1684 }
1685 catch (Exception e) {
1686 }
1687
1688 return getScopeGroupId(layout);
1689 }
1690
1691 public long getScopeGroupId(Layout layout) {
1692 if (layout == null) {
1693 return 0;
1694 }
1695 else {
1696 return layout.getGroupId();
1697 }
1698 }
1699
1700 public long getScopeGroupId(HttpServletRequest request) {
1701 Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
1702
1703 return getScopeGroupId(layout);
1704 }
1705
1706 public long getScopeGroupId(PortletRequest portletRequest) {
1707 return getScopeGroupId(getHttpServletRequest(portletRequest));
1708 }
1709
1710 public User getSelectedUser(HttpServletRequest request)
1711 throws PortalException, RemoteException, SystemException {
1712
1713 return getSelectedUser(request, true);
1714 }
1715
1716 public User getSelectedUser(
1717 HttpServletRequest request, boolean checkPermission)
1718 throws PortalException, RemoteException, SystemException {
1719
1720 long userId = ParamUtil.getLong(request, "p_u_i_d");
1721
1722 User user = null;
1723
1724 try {
1725 if (checkPermission) {
1726 user = UserServiceUtil.getUserById(userId);
1727 }
1728 else {
1729 user = UserLocalServiceUtil.getUserById(userId);
1730 }
1731 }
1732 catch (NoSuchUserException nsue) {
1733 }
1734
1735 return user;
1736 }
1737
1738 public User getSelectedUser(PortletRequest portletRequest)
1739 throws PortalException, RemoteException, SystemException {
1740
1741 return getSelectedUser(portletRequest, true);
1742 }
1743
1744 public User getSelectedUser(
1745 PortletRequest portletRequest, boolean checkPermission)
1746 throws PortalException, RemoteException, SystemException {
1747
1748 return getSelectedUser(
1749 getHttpServletRequest(portletRequest), checkPermission);
1750 }
1751
1752 public String getStrutsAction(HttpServletRequest request) {
1753 String strutsAction = ParamUtil.getString(request, "struts_action");
1754
1755 if (Validator.isNotNull(strutsAction)) {
1756
1757
1761 return StringPool.BLANK;
1762 }
1763
1764 return _getPortletParam(request, "struts_action");
1765 }
1766
1767 public String[] getSystemCommunityRoles() {
1768 return _allSystemCommunityRoles;
1769 }
1770
1771 public String[] getSystemGroups() {
1772 return _allSystemGroups;
1773 }
1774
1775 public String[] getSystemOrganizationRoles() {
1776 return _allSystemOrganizationRoles;
1777 }
1778
1779 public String[] getSystemRoles() {
1780 return _allSystemRoles;
1781 }
1782
1783 public UploadPortletRequest getUploadPortletRequest(
1784 ActionRequest actionRequest) {
1785
1786 if (actionRequest instanceof ActionRequestImpl) {
1787 ActionRequestImpl actionRequestImpl =
1788 (ActionRequestImpl)actionRequest;
1789
1790 DynamicServletRequest dynamicRequest =
1791 (DynamicServletRequest)
1792 actionRequestImpl.getHttpServletRequest();
1793
1794 HttpServletRequestWrapper requestWrapper =
1795 (HttpServletRequestWrapper)dynamicRequest.getRequest();
1796
1797 UploadServletRequest uploadRequest = getUploadServletRequest(
1798 requestWrapper);
1799
1800 return new UploadPortletRequestImpl(
1801 uploadRequest,
1802 PortalUtil.getPortletNamespace(
1803 actionRequestImpl.getPortletName()));
1804
1805 }
1806 else {
1807
1808 com.sun.portal.portletcontainer.portlet.impl.ActionRequestImpl
1809 actionRequestImpl =
1810 (com.sun.portal.portletcontainer.portlet.impl.ActionRequestImpl)
1811 actionRequest;
1812
1813 HttpServletRequestWrapper requestWrapper =
1814 (HttpServletRequestWrapper)
1815 actionRequestImpl.getHttpServletRequest();
1816
1817 UploadServletRequest uploadRequest = getUploadServletRequest(
1818 requestWrapper);
1819
1820 String portletWindowName = (String)actionRequest.getAttribute(
1821 "javax.portlet.portletc.portletWindowName");
1822
1823 return new UploadPortletRequestImpl(
1824 uploadRequest,
1825 PortalUtil.getPortletNamespace(portletWindowName));
1826 }
1827
1828 }
1829
1830 public UploadServletRequest getUploadServletRequest(
1831 HttpServletRequest request) {
1832
1833 HttpServletRequestWrapper requestWrapper = null;
1834
1835 if (request instanceof HttpServletRequestWrapper) {
1836 requestWrapper = (HttpServletRequestWrapper)request;
1837 }
1838
1839 UploadServletRequest uploadRequest = null;
1840
1841 while (uploadRequest == null) {
1842
1843
1846 if (requestWrapper instanceof UploadServletRequest) {
1847 uploadRequest = (UploadServletRequest)requestWrapper;
1848 }
1849 else {
1850 HttpServletRequest parentRequest =
1851 (HttpServletRequest)requestWrapper.getRequest();
1852
1853 if (!(parentRequest instanceof HttpServletRequestWrapper)) {
1854
1855
1858 uploadRequest = new UploadServletRequestImpl(parentRequest);
1859
1860 break;
1861 }
1862 else {
1863 requestWrapper = (HttpServletRequestWrapper)parentRequest;
1864 }
1865 }
1866 }
1867
1868 return uploadRequest;
1869 }
1870
1871 public Date getUptime() {
1872 return UP_TIME;
1873 }
1874
1875 public String getURLWithSessionId(String url, String sessionId) {
1876 if (!PropsValues.SESSION_ENABLE_URL_WITH_SESSION_ID) {
1877 return url;
1878 }
1879
1880
1882 int x = url.indexOf(StringPool.SEMICOLON);
1883
1884 if (x != -1) {
1885 return url;
1886 }
1887
1888 x = url.indexOf(StringPool.QUESTION);
1889
1890 if (x != -1) {
1891 StringBuilder sb = new StringBuilder();
1892
1893 sb.append(url.substring(0, x));
1894 sb.append(_JSESSIONID);
1895 sb.append(sessionId);
1896 sb.append(url.substring(x));
1897
1898 return sb.toString();
1899 }
1900
1901
1904 x = url.indexOf(StringPool.DOUBLE_SLASH);
1905
1906 StringBuilder sb = new StringBuilder();
1907
1908 sb.append(url);
1909
1910 if (x != -1) {
1911 int y = url.lastIndexOf(StringPool.SLASH);
1912
1913 if (x + 1 == y) {
1914 sb.append(StringPool.SLASH);
1915 }
1916 }
1917
1918 sb.append(_JSESSIONID);
1919 sb.append(sessionId);
1920
1921 return sb.toString();
1922 }
1923
1924 public User getUser(HttpServletRequest request)
1925 throws PortalException, SystemException {
1926
1927 long userId = getUserId(request);
1928
1929 if (userId <= 0) {
1930
1931
1936 String remoteUser = request.getRemoteUser();
1937
1938 if (remoteUser == null) {
1939 return null;
1940 }
1941
1942 userId = GetterUtil.getLong(remoteUser);
1943 }
1944
1945 User user = (User)request.getAttribute(WebKeys.USER);
1946
1947 if (user == null) {
1948 user = UserLocalServiceUtil.getUserById(userId);
1949
1950 request.setAttribute(WebKeys.USER, user);
1951 }
1952
1953 return user;
1954 }
1955
1956 public User getUser(PortletRequest portletRequest)
1957 throws PortalException, SystemException {
1958
1959 return getUser(getHttpServletRequest(portletRequest));
1960 }
1961
1962 public long getUserId(HttpServletRequest request) {
1963 Long userIdObj = (Long)request.getAttribute(WebKeys.USER_ID);
1964
1965 if (userIdObj != null) {
1966 return userIdObj.longValue();
1967 }
1968
1969 if (!PropsValues.PORTAL_JAAS_ENABLE &&
1970 PropsValues.PORTAL_IMPERSONATION_ENABLE) {
1971
1972 String doAsUserIdString = ParamUtil.getString(
1973 request, "doAsUserId");
1974
1975 try {
1976 long doAsUserId = getDoAsUserId(request, doAsUserIdString);
1977
1978 if (doAsUserId > 0) {
1979 if (_log.isDebugEnabled()) {
1980 _log.debug("Impersonating user " + doAsUserId);
1981 }
1982
1983 return doAsUserId;
1984 }
1985 }
1986 catch (Exception e) {
1987 _log.error("Unable to impersonate user " + doAsUserIdString, e);
1988 }
1989 }
1990
1991 HttpSession session = request.getSession();
1992
1993 userIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
1994
1995 if (userIdObj != null) {
1996 request.setAttribute(WebKeys.USER_ID, userIdObj);
1997
1998 return userIdObj.longValue();
1999 }
2000 else {
2001 return 0;
2002 }
2003 }
2004
2005 public long getUserId(PortletRequest portletRequest) {
2006 return getUserId(getHttpServletRequest(portletRequest));
2007 }
2008
2009 public String getUserName(long userId, String defaultUserName) {
2010 return getUserName(
2011 userId, defaultUserName, UserAttributes.USER_NAME_FULL);
2012 }
2013
2014 public String getUserName(
2015 long userId, String defaultUserName, String userAttribute) {
2016
2017 return getUserName(userId, defaultUserName, userAttribute, null);
2018 }
2019
2020 public String getUserName(
2021 long userId, String defaultUserName, HttpServletRequest request) {
2022
2023 return getUserName(
2024 userId, defaultUserName, UserAttributes.USER_NAME_FULL, request);
2025 }
2026
2027 public String getUserName(
2028 long userId, String defaultUserName, String userAttribute,
2029 HttpServletRequest request) {
2030
2031 String userName = defaultUserName;
2032
2033 try {
2034 User user = UserLocalServiceUtil.getUserById(userId);
2035
2036 if (userAttribute.equals(UserAttributes.USER_NAME_FULL)) {
2037 userName = user.getFullName();
2038 }
2039 else {
2040 userName = user.getScreenName();
2041 }
2042
2043 if (request != null) {
2044 Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
2045
2046 PortletURL portletURL = new PortletURLImpl(
2047 request, PortletKeys.DIRECTORY, layout.getPlid(),
2048 PortletRequest.RENDER_PHASE);
2049
2050 portletURL.setWindowState(WindowState.MAXIMIZED);
2051 portletURL.setPortletMode(PortletMode.VIEW);
2052
2053 portletURL.setParameter(
2054 "struts_action", "/directory/edit_user");
2055 portletURL.setParameter(
2056 "p_u_i_d", String.valueOf(user.getUserId()));
2057
2058 userName =
2059 "<a href=\"" + portletURL.toString() + "\">" + userName +
2060 "</a>";
2061 }
2062 }
2063 catch (Exception e) {
2064 }
2065
2066 return userName;
2067 }
2068
2069 public String getUserPassword(HttpSession session) {
2070 return (String)session.getAttribute(WebKeys.USER_PASSWORD);
2071 }
2072
2073 public String getUserPassword(HttpServletRequest request) {
2074 HttpSession session = request.getSession();
2075
2076 return getUserPassword(session);
2077 }
2078
2079 public String getUserPassword(PortletRequest portletRequest) {
2080 return getUserPassword(getHttpServletRequest(portletRequest));
2081 }
2082
2083 public String getUserValue(long userId, String param, String defaultValue)
2084 throws SystemException {
2085
2086 if (Validator.isNotNull(defaultValue)) {
2087 return defaultValue;
2088 }
2089 else {
2090 try {
2091 User user = UserLocalServiceUtil.getUserById(userId);
2092
2093 return BeanPropertiesUtil.getString(user, param, defaultValue);
2094 }
2095 catch (PortalException pe) {
2096 return StringPool.BLANK;
2097 }
2098 }
2099 }
2100
2101 public String getWidgetURL(Portlet portlet, ThemeDisplay themeDisplay) {
2102 String layoutURL = getLayoutURL(themeDisplay);
2103
2104 Layout layout = themeDisplay.getLayout();
2105
2106 StringBuilder sb = new StringBuilder();
2107
2108 if (HttpUtil.hasDomain(layoutURL)) {
2109 String protocol = HttpUtil.getProtocol(layoutURL);
2110 String domain = HttpUtil.getDomain(layoutURL);
2111 HttpUtil.removeDomain(layoutURL);
2112
2113 sb.append(protocol);
2114 sb.append(Http.PROTOCOL_DELIMITER);
2115 sb.append(domain);
2116
2117 if (Validator.isNotNull(_pathContext)) {
2118 sb.append(_pathContext);
2119 }
2120
2121 if (themeDisplay.isI18n()) {
2122 sb.append(StringPool.SLASH);
2123 sb.append(themeDisplay.getI18nLanguageId());
2124 }
2125
2126 sb.append(PropsValues.WIDGET_SERVLET_MAPPING);
2127 sb.append(layout.getFriendlyURL());
2128 }
2129 else {
2130 sb.append(themeDisplay.getPortalURL());
2131
2132 if (Validator.isNotNull(_pathContext)) {
2133 sb.append(_pathContext);
2134 }
2135
2136 if (themeDisplay.isI18n()) {
2137 sb.append(StringPool.SLASH);
2138 sb.append(themeDisplay.getI18nLanguageId());
2139 }
2140
2141 sb.append(PropsValues.WIDGET_SERVLET_MAPPING);
2142
2143 Group group = layout.getGroup();
2144
2145 if (layout.isPrivateLayout()) {
2146 if (group.isUser()) {
2147 sb.append(_PRIVATE_USER_SERVLET_MAPPING);
2148 }
2149 else {
2150 sb.append(_PRIVATE_GROUP_SERVLET_MAPPING);
2151 }
2152 }
2153 else {
2154 sb.append(_PUBLIC_GROUP_SERVLET_MAPPING);
2155 }
2156
2157 sb.append(group.getFriendlyURL());
2158 sb.append(layout.getFriendlyURL());
2159 }
2160
2161 sb.append("/-/");
2162
2163 FriendlyURLMapper friendlyURLMapper =
2164 portlet.getFriendlyURLMapperInstance();
2165
2166 if ((friendlyURLMapper != null) && !portlet.isInstanceable()) {
2167 sb.append(friendlyURLMapper.getMapping());
2168 }
2169 else {
2170 sb.append(portlet.getPortletId());
2171 }
2172
2173 return sb.toString();
2174 }
2175
2176 public boolean isMethodGet(PortletRequest portletRequest) {
2177 HttpServletRequest request = getHttpServletRequest(portletRequest);
2178
2179 String method = GetterUtil.getString(request.getMethod());
2180
2181 if (method.equalsIgnoreCase(HttpMethods.GET)) {
2182 return true;
2183 }
2184 else {
2185 return false;
2186 }
2187 }
2188
2189 public boolean isMethodPost(PortletRequest portletRequest) {
2190 HttpServletRequest request = getHttpServletRequest(portletRequest);
2191
2192 String method = GetterUtil.getString(request.getMethod());
2193
2194 if (method.equalsIgnoreCase(HttpMethods.POST)) {
2195 return true;
2196 }
2197 else {
2198 return false;
2199 }
2200 }
2201
2202 public boolean isLayoutFriendliable(Layout layout) {
2203 return GetterUtil.getBoolean(
2204 PropsUtil.get(
2205 PropsKeys.LAYOUT_URL_FRIENDLIABLE,
2206 new Filter(layout.getType())),
2207 true);
2208 }
2209
2210 public boolean isLayoutParentable(Layout layout) {
2211 return isLayoutParentable(layout.getType());
2212 }
2213
2214 public boolean isLayoutParentable(String type) {
2215 return GetterUtil.getBoolean(
2216 PropsUtil.get(PropsKeys.LAYOUT_PARENTABLE, new Filter(type)), true);
2217 }
2218
2219 public boolean isLayoutSitemapable(Layout layout) {
2220 if (layout.isPrivateLayout()) {
2221 return false;
2222 }
2223
2224 return GetterUtil.getBoolean(PropsUtil.get(
2225 PropsKeys.LAYOUT_SITEMAPABLE, new Filter(layout.getType())), true);
2226 }
2227
2228 public boolean isReservedParameter(String name) {
2229 return _reservedParams.contains(name);
2230 }
2231
2232 public boolean isSystemGroup(String groupName) {
2233 if (groupName == null) {
2234 return false;
2235 }
2236
2237 groupName = groupName.trim();
2238
2239 int pos = Arrays.binarySearch(
2240 _sortedSystemGroups, groupName, new StringComparator());
2241
2242 if (pos >= 0) {
2243 return true;
2244 }
2245 else {
2246 return false;
2247 }
2248 }
2249
2250 public boolean isSystemRole(String roleName) {
2251 if (roleName == null) {
2252 return false;
2253 }
2254
2255 roleName = roleName.trim();
2256
2257 int pos = Arrays.binarySearch(
2258 _sortedSystemRoles, roleName, new StringComparator());
2259
2260 if (pos >= 0) {
2261 return true;
2262 }
2263 else {
2264 pos = Arrays.binarySearch(
2265 _sortedSystemCommunityRoles, roleName, new StringComparator());
2266
2267 if (pos >= 0) {
2268 return true;
2269 }
2270 else {
2271 pos = Arrays.binarySearch(
2272 _sortedSystemOrganizationRoles, roleName,
2273 new StringComparator());
2274
2275 if (pos >= 0) {
2276 return true;
2277 }
2278 }
2279 }
2280
2281 return false;
2282 }
2283
2284 public boolean isUpdateAvailable()
2285 throws PortalException, SystemException {
2286
2287 return PluginPackageUtil.isUpdateAvailable();
2288 }
2289
2290 public void renderPage(
2291 StringBuilder sb, ServletContext servletContext,
2292 HttpServletRequest request, HttpServletResponse response,
2293 String path)
2294 throws IOException, ServletException {
2295
2296 RequestDispatcher requestDispatcher =
2297 servletContext.getRequestDispatcher(path);
2298
2299 StringServletResponse stringResponse = new StringServletResponse(
2300 response);
2301
2302 requestDispatcher.include(request, stringResponse);
2303
2304 sb.append(stringResponse.getString());
2305 }
2306
2307 public void renderPortlet(
2308 StringBuilder sb, ServletContext servletContext,
2309 HttpServletRequest request, HttpServletResponse response,
2310 Portlet portlet, String queryString)
2311 throws IOException, ServletException {
2312
2313 renderPortlet(
2314 sb, servletContext, request, response, portlet, queryString, null,
2315 null, null);
2316 }
2317
2318 public void renderPortlet(
2319 StringBuilder sb, ServletContext servletContext,
2320 HttpServletRequest request, HttpServletResponse response,
2321 Portlet portlet, String queryString, String columnId,
2322 Integer columnPos, Integer columnCount)
2323 throws IOException, ServletException {
2324
2325 renderPortlet(
2326 sb, servletContext, request, response, portlet, queryString,
2327 columnId, columnPos, columnCount, null);
2328 }
2329
2330 public void renderPortlet(
2331 StringBuilder sb, ServletContext servletContext,
2332 HttpServletRequest request, HttpServletResponse response,
2333 Portlet portlet, String queryString, String columnId,
2334 Integer columnPos, Integer columnCount, String path)
2335 throws IOException, ServletException {
2336
2337 queryString = GetterUtil.getString(queryString);
2338 columnId = GetterUtil.getString(columnId);
2339
2340 if (columnPos == null) {
2341 columnPos = new Integer(0);
2342 }
2343
2344 if (columnCount == null) {
2345 columnCount = new Integer(0);
2346 }
2347
2348 request.setAttribute(WebKeys.RENDER_PORTLET, portlet);
2349 request.setAttribute(WebKeys.RENDER_PORTLET_QUERY_STRING, queryString);
2350 request.setAttribute(WebKeys.RENDER_PORTLET_COLUMN_ID, columnId);
2351 request.setAttribute(WebKeys.RENDER_PORTLET_COLUMN_POS, columnPos);
2352 request.setAttribute(WebKeys.RENDER_PORTLET_COLUMN_COUNT, columnCount);
2353
2354 if (path == null) {
2355 path = "/html/portal/render_portlet.jsp";
2356 }
2357
2358 RequestDispatcher requestDispatcher =
2359 servletContext.getRequestDispatcher(path);
2360
2361 if (sb != null) {
2362 StringServletResponse stringResponse = new StringServletResponse(
2363 response);
2364
2365 requestDispatcher.include(request, stringResponse);
2366
2367 sb.append(stringResponse.getString());
2368 }
2369 else {
2370
2371
2373 response.setContentType(ContentTypes.TEXT_HTML_UTF8);
2374
2375 requestDispatcher.include(request, response);
2376 }
2377 }
2378
2379 public void sendError(
2380 Exception e, HttpServletRequest request,
2381 HttpServletResponse response)
2382 throws IOException, ServletException {
2383
2384 sendError(0, e, request, response);
2385 }
2386
2387 public void sendError(
2388 int status, Exception e, HttpServletRequest request,
2389 HttpServletResponse response)
2390 throws IOException, ServletException {
2391
2392 if (status == 0) {
2393 if (e instanceof PrincipalException) {
2394 status = HttpServletResponse.SC_FORBIDDEN;
2395 }
2396 else {
2397 String name = e.getClass().getName();
2398
2399 name = name.substring(name.lastIndexOf(StringPool.PERIOD) + 1);
2400
2401 if (name.startsWith("NoSuch") && name.endsWith("Exception")) {
2402 status = HttpServletResponse.SC_NOT_FOUND;
2403 }
2404 }
2405
2406 if (status == 0) {
2407 status = HttpServletResponse.SC_INTERNAL_SERVER_ERROR;
2408 }
2409 }
2410
2411 HttpSession session = request.getSession();
2412
2413 ServletContext servletContext = session.getServletContext();
2414
2415 String redirect = PATH_MAIN + "/portal/status";
2416
2417 if (e instanceof NoSuchLayoutException &&
2418 Validator.isNotNull(
2419 PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND)) {
2420
2421 response.setStatus(status);
2422
2423 redirect = PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND;
2424
2425 RequestDispatcher requestDispatcher =
2426 servletContext.getRequestDispatcher(redirect);
2427
2428 if (requestDispatcher != null) {
2429 requestDispatcher.forward(request, response);
2430 }
2431 }
2432 else if (PropsValues.LAYOUT_SHOW_HTTP_STATUS) {
2433 response.setStatus(status);
2434
2435 SessionErrors.add(request, e.getClass().getName(), e);
2436
2437 RequestDispatcher requestDispatcher =
2438 servletContext.getRequestDispatcher(redirect);
2439
2440 if (requestDispatcher != null) {
2441 requestDispatcher.forward(request, response);
2442 }
2443 }
2444 else {
2445 if (e != null) {
2446 response.sendError(status, e.getMessage());
2447 }
2448 else {
2449 response.sendError(status);
2450 }
2451 }
2452 }
2453
2454 public void sendError(
2455 Exception e, ActionRequest actionRequest,
2456 ActionResponse actionResponse)
2457 throws IOException {
2458
2459 sendError(0, e, actionRequest, actionResponse);
2460 }
2461
2462 public void sendError(
2463 int status, Exception e, ActionRequest actionRequest,
2464 ActionResponse actionResponse)
2465 throws IOException {
2466
2467 StringBuilder sb = new StringBuilder();
2468
2469 sb.append(_pathContext);
2470 sb.append("/portal/status?status=");
2471 sb.append(status);
2472 sb.append("&exception=");
2473 sb.append(e.getClass().getName());
2474 sb.append("&previousURL=");
2475 sb.append(HttpUtil.encodeURL(PortalUtil.getCurrentURL(actionRequest)));
2476
2477 actionResponse.sendRedirect(sb.toString());
2478 }
2479
2480
2487 public void setPageSubtitle(String subtitle, HttpServletRequest request) {
2488 request.setAttribute(WebKeys.PAGE_SUBTITLE, subtitle);
2489 }
2490
2491
2498 public void setPageTitle(String title, HttpServletRequest request) {
2499 request.setAttribute(WebKeys.PAGE_TITLE, title);
2500 }
2501
2502
2507 public void setPortalPort(HttpServletRequest request) {
2508 if (_portalPort.intValue() == -1) {
2509 synchronized (_portalPort) {
2510 _portalPort = new Integer(request.getServerPort());
2511 }
2512 }
2513 }
2514
2515 public void storePreferences(PortletPreferences prefs)
2516 throws IOException, ValidatorException {
2517
2518 PortletPreferencesWrapper prefsWrapper =
2519 (PortletPreferencesWrapper)prefs;
2520
2521 PortletPreferencesImpl prefsImpl = prefsWrapper.getPreferencesImpl();
2522
2523 prefsImpl.store();
2524 }
2525
2526 public String transformCustomSQL(String sql) {
2527 if ((_customSqlClassNames == null) ||
2528 (_customSqlClassNameIds == null)) {
2529
2530 _initCustomSQL();
2531 }
2532
2533 return StringUtil.replace(
2534 sql, _customSqlClassNames, _customSqlClassNameIds);
2535 }
2536
2537 public PortletMode updatePortletMode(
2538 String portletId, User user, Layout layout, PortletMode portletMode,
2539 HttpServletRequest request) {
2540
2541 LayoutTypePortlet layoutType =
2542 (LayoutTypePortlet)layout.getLayoutType();
2543
2544 if (portletMode == null || Validator.isNull(portletMode.toString())) {
2545 if (layoutType.hasModeAboutPortletId(portletId)) {
2546 return LiferayPortletMode.ABOUT;
2547 }
2548 else if (layoutType.hasModeConfigPortletId(portletId)) {
2549 return LiferayPortletMode.CONFIG;
2550 }
2551 else if (layoutType.hasModeEditPortletId(portletId)) {
2552 return PortletMode.EDIT;
2553 }
2554 else if (layoutType.hasModeEditDefaultsPortletId(portletId)) {
2555 return LiferayPortletMode.EDIT_DEFAULTS;
2556 }
2557 else if (layoutType.hasModeEditGuestPortletId(portletId)) {
2558 return LiferayPortletMode.EDIT_GUEST;
2559 }
2560 else if (layoutType.hasModeHelpPortletId(portletId)) {
2561 return PortletMode.HELP;
2562 }
2563 else if (layoutType.hasModePreviewPortletId(portletId)) {
2564 return LiferayPortletMode.PREVIEW;
2565 }
2566 else if (layoutType.hasModePrintPortletId(portletId)) {
2567 return LiferayPortletMode.PRINT;
2568 }
2569 else {
2570 return PortletMode.VIEW;
2571 }
2572 }
2573 else {
2574 boolean updateLayout = false;
2575
2576 if (portletMode.equals(LiferayPortletMode.ABOUT) &&
2577 !layoutType.hasModeAboutPortletId(portletId)) {
2578
2579 layoutType.addModeAboutPortletId(portletId);
2580
2581 updateLayout = true;
2582 }
2583 else if (portletMode.equals(LiferayPortletMode.CONFIG) &&
2584 !layoutType.hasModeConfigPortletId(portletId)) {
2585
2586 layoutType.addModeConfigPortletId(portletId);
2587
2588 updateLayout = true;
2589 }
2590 else if (portletMode.equals(PortletMode.EDIT) &&
2591 !layoutType.hasModeEditPortletId(portletId)) {
2592
2593 layoutType.addModeEditPortletId(portletId);
2594
2595 updateLayout = true;
2596 }
2597 else if (portletMode.equals(LiferayPortletMode.EDIT_DEFAULTS) &&
2598 !layoutType.hasModeEditDefaultsPortletId(portletId)) {
2599
2600 layoutType.addModeEditDefaultsPortletId(portletId);
2601
2602 updateLayout = true;
2603 }
2604 else if (portletMode.equals(LiferayPortletMode.EDIT_GUEST) &&
2605 !layoutType.hasModeEditGuestPortletId(portletId)) {
2606
2607 layoutType.addModeEditGuestPortletId(portletId);
2608
2609 updateLayout = true;
2610 }
2611 else if (portletMode.equals(PortletMode.HELP) &&
2612 !layoutType.hasModeHelpPortletId(portletId)) {
2613
2614 layoutType.addModeHelpPortletId(portletId);
2615
2616 updateLayout = true;
2617 }
2618 else if (portletMode.equals(LiferayPortletMode.PREVIEW) &&
2619 !layoutType.hasModePreviewPortletId(portletId)) {
2620
2621 layoutType.addModePreviewPortletId(portletId);
2622
2623 updateLayout = true;
2624 }
2625 else if (portletMode.equals(LiferayPortletMode.PRINT) &&
2626 !layoutType.hasModePrintPortletId(portletId)) {
2627
2628 layoutType.addModePrintPortletId(portletId);
2629
2630 updateLayout = true;
2631 }
2632 else if (portletMode.equals(PortletMode.VIEW) &&
2633 !layoutType.hasModeViewPortletId(portletId)) {
2634
2635 layoutType.removeModesPortletId(portletId);
2636
2637 updateLayout = true;
2638 }
2639
2640 if (updateLayout) {
2641 LayoutClone layoutClone = LayoutCloneFactory.getInstance();
2642
2643 if (layoutClone != null) {
2644 layoutClone.update(
2645 request, layout.getPlid(), layout.getTypeSettings());
2646 }
2647 }
2648
2649 return portletMode;
2650 }
2651 }
2652
2653 public WindowState updateWindowState(
2654 String portletId, User user, Layout layout, WindowState windowState,
2655 HttpServletRequest request) {
2656
2657 LayoutTypePortlet layoutType =
2658 (LayoutTypePortlet)layout.getLayoutType();
2659
2660 if ((windowState == null) ||
2661 (Validator.isNull(windowState.toString()))) {
2662
2663 if (layoutType.hasStateMaxPortletId(portletId)) {
2664 return WindowState.MAXIMIZED;
2665 }
2666 else if (layoutType.hasStateMinPortletId(portletId)) {
2667 return WindowState.MINIMIZED;
2668 }
2669 else {
2670 return WindowState.NORMAL;
2671 }
2672 }
2673 else {
2674 boolean updateLayout = false;
2675
2676 if (windowState.equals(WindowState.MAXIMIZED) &&
2677 !layoutType.hasStateMaxPortletId(portletId)) {
2678
2679 layoutType.addStateMaxPortletId(portletId);
2680
2681 updateLayout = false;
2682 }
2683 else if (windowState.equals(WindowState.MINIMIZED) &&
2684 !layoutType.hasStateMinPortletId(portletId)) {
2685
2686 layoutType.addStateMinPortletId(portletId);
2687
2688 updateLayout = true;
2689 }
2690 else if (windowState.equals(WindowState.NORMAL) &&
2691 !layoutType.hasStateNormalPortletId(portletId)) {
2692
2693 layoutType.removeStatesPortletId(portletId);
2694
2695 updateLayout = true;
2696 }
2697
2698 if (updateLayout) {
2699 LayoutClone layoutClone = LayoutCloneFactory.getInstance();
2700
2701 if (layoutClone != null) {
2702 layoutClone.update(
2703 request, layout.getPlid(), layout.getTypeSettings());
2704 }
2705 }
2706
2707 return windowState;
2708 }
2709 }
2710
2711 protected long getDoAsUserId(
2712 HttpServletRequest request, String doAsUserIdString)
2713 throws Exception {
2714
2715 if (Validator.isNull(doAsUserIdString)) {
2716 return 0;
2717 }
2718
2719 long doAsUserId = 0;
2720
2721 try {
2722 Company company = getCompany(request);
2723
2724 doAsUserId = GetterUtil.getLong(
2725 Encryptor.decrypt(company.getKeyObj(), doAsUserIdString));
2726 }
2727 catch (Exception e) {
2728 if (_log.isWarnEnabled()) {
2729 _log.warn(
2730 "Unable to impersonate " + doAsUserIdString +
2731 " because the string cannot be decrypted",
2732 e);
2733 }
2734
2735 return 0;
2736 }
2737
2738 String path = GetterUtil.getString(request.getPathInfo());
2739
2740 if (_log.isDebugEnabled()) {
2741 _log.debug("doAsUserId path " + path);
2742 }
2743
2744 String strutsAction = getStrutsAction(request);
2745
2746 if (_log.isDebugEnabled()) {
2747 _log.debug("Struts action " + strutsAction);
2748 }
2749
2750 String actionName = _getPortletParam(request, "actionName");
2751
2752 if (_log.isDebugEnabled()) {
2753 _log.debug("Action name " + actionName);
2754 }
2755
2756 boolean alwaysAllowDoAsUser = false;
2757
2758 if (path.equals("/portal/fckeditor") ||
2759 strutsAction.equals("/document_library/edit_file_entry") ||
2760 strutsAction.equals("/image_gallery/edit_image") ||
2761 strutsAction.equals("/wiki/edit_page_attachment") ||
2762 actionName.equals("addFile")) {
2763
2764 alwaysAllowDoAsUser = true;
2765 }
2766
2767 if (_log.isDebugEnabled()) {
2768 if (alwaysAllowDoAsUser) {
2769 _log.debug(
2770 "doAsUserId path or Struts action is always allowed");
2771 }
2772 else {
2773 _log.debug(
2774 "doAsUserId path is Struts action not always allowed");
2775 }
2776 }
2777
2778 if (alwaysAllowDoAsUser) {
2779 request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
2780
2781 return doAsUserId;
2782 }
2783
2784 HttpSession session = request.getSession();
2785
2786 Long realUserIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
2787
2788 if (realUserIdObj == null) {
2789 return 0;
2790 }
2791
2792 User doAsUser = UserLocalServiceUtil.getUserById(doAsUserId);
2793
2794 long[] organizationIds = doAsUser.getOrganizationIds();
2795
2796 User realUser = UserLocalServiceUtil.getUserById(
2797 realUserIdObj.longValue());
2798 boolean checkGuest = true;
2799
2800 PermissionChecker permissionChecker = null;
2801
2802 try {
2803 permissionChecker = PermissionCheckerFactory.create(
2804 realUser, checkGuest);
2805
2806 if (doAsUser.isDefaultUser() ||
2807 UserPermissionUtil.contains(
2808 permissionChecker, doAsUserId, organizationIds,
2809 ActionKeys.IMPERSONATE)) {
2810
2811 request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
2812
2813 return doAsUserId;
2814 }
2815 else {
2816 _log.error(
2817 "User " + realUserIdObj + " does not have the permission " +
2818 "to impersonate " + doAsUserId);
2819
2820 return 0;
2821 }
2822 }
2823 finally {
2824 try {
2825 PermissionCheckerFactory.recycle(permissionChecker);
2826 }
2827 catch (Exception e) {
2828 }
2829 }
2830 }
2831
2832 private String _getCurrentURL(HttpServletRequest request) {
2833 StringBuilder sb = new StringBuilder();
2834
2835 StringBuffer requestURL = request.getRequestURL();
2836
2837 if (requestURL != null) {
2838 sb.append(requestURL.toString());
2839 }
2840
2841 String queryString = request.getQueryString();
2842
2843 if (Validator.isNull(queryString)) {
2844 return sb.toString();
2845 }
2846
2847 String portletId = request.getParameter("p_p_id");
2848
2849 String redirectParam = "redirect";
2850
2851 if (Validator.isNotNull(portletId)) {
2852 redirectParam = getPortletNamespace(portletId) + redirectParam;
2853 }
2854
2855 Map<String, String[]> parameterMap = HttpUtil.parameterMapFromString(
2856 queryString);
2857
2858 String[] redirectValues = parameterMap.get(redirectParam);
2859
2860 if ((redirectValues != null) && (redirectValues.length > 0)) {
2861
2862
2866 String redirect = HttpUtil.decodeURL(
2867 GetterUtil.getString(redirectValues[0]));
2868
2869 int pos = redirect.indexOf(StringPool.QUESTION);
2870
2871 if (pos != -1) {
2872 String subqueryString = redirect.substring(
2873 pos + 1, redirect.length());
2874
2875 Map<String, String[]> subparameterMap =
2876 HttpUtil.parameterMapFromString(subqueryString);
2877
2878 String[] subredirectValues = subparameterMap.get(redirectParam);
2879
2880 if ((subredirectValues != null) &&
2881 (subredirectValues.length > 0)) {
2882
2883 String subredirect = HttpUtil.decodeURL(
2884 GetterUtil.getString(subredirectValues[0]));
2885
2886 parameterMap.put(redirectParam, new String[] {subredirect});
2887
2888 queryString = HttpUtil.parameterMapToString(
2889 parameterMap, false);
2890 }
2891 }
2892 }
2893
2894 sb.append(StringPool.QUESTION);
2895 sb.append(queryString);
2896
2897 return sb.toString();
2898 }
2899
2900 private long _getPlidFromPortletId(
2901 long groupId, boolean privateLayout, String portletId) {
2902
2903 long plid = LayoutConstants.DEFAULT_PLID;
2904
2905 try {
2906 List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
2907 groupId, privateLayout, LayoutConstants.TYPE_PORTLET);
2908
2909 for (Layout layout : layouts) {
2910 LayoutTypePortlet layoutTypePortlet =
2911 (LayoutTypePortlet)layout.getLayoutType();
2912
2913 if (layoutTypePortlet.hasPortletId(portletId)) {
2914 plid = layout.getPlid();
2915
2916 break;
2917 }
2918 }
2919 }
2920 catch (SystemException se) {
2921 if (_log.isWarnEnabled()) {
2922 _log.warn(se.getMessage());
2923 }
2924 }
2925
2926 return plid;
2927 }
2928
2929 private String _getPortletParam(HttpServletRequest request, String name) {
2930 String value = null;
2931
2932 int valueCount = 0;
2933
2934 Enumeration<String> enu = request.getParameterNames();
2935
2936 while (enu.hasMoreElements()) {
2937 String curName = enu.nextElement();
2938
2939 int pos = curName.indexOf(StringPool.UNDERLINE + name);
2940
2941 if (pos != -1) {
2942 valueCount++;
2943
2944
2946 if (valueCount > 1) {
2947 return StringPool.BLANK;
2948 }
2949
2950 String curValue = ParamUtil.getString(request, curName);
2951
2952 if (Validator.isNotNull(curValue)) {
2953
2954
2956 String portletId1 = curName.substring(1, pos);
2957 String portletId2 = ParamUtil.getString(request, "p_p_id");
2958
2959 if (portletId1.equals(portletId2)) {
2960 value = curValue;
2961 }
2962 }
2963 }
2964 }
2965
2966 if (value == null) {
2967 value = StringPool.BLANK;
2968 }
2969
2970 return value;
2971 }
2972
2973 private void _initCustomSQL() {
2974 _customSqlClassNames = new String[] {
2975 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ORGANIZATION$]",
2976 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USER$]",
2977 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USERGROUP$]",
2978 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BLOGS.MODEL.BLOGSENTRY$]",
2979 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BOOKMARKS.MODEL." +
2980 "BOOKMARKSENTRY$]",
2981 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.DOCUMENTLIBRARY.MODEL." +
2982 "DLFILEENTRY$]",
2983 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.IMAGEGALLERY.MODEL.IGIMAGE$]",
2984 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.MESSAGEBOARDS.MODEL." +
2985 "MBMESSAGE$]",
2986 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.WIKI.MODEL.WIKIPAGE$]",
2987 "[$FALSE$]",
2988 "[$TRUE$]"
2989 };
2990
2991 DBUtil dbUtil = DBUtil.getInstance();
2992
2993 _customSqlClassNameIds = new String[] {
2994 String.valueOf(PortalUtil.getClassNameId(Organization.class)),
2995 String.valueOf(PortalUtil.getClassNameId(User.class)),
2996 String.valueOf(PortalUtil.getClassNameId(UserGroup.class)),
2997 String.valueOf(PortalUtil.getClassNameId(BlogsEntry.class)),
2998 String.valueOf(PortalUtil.getClassNameId(BookmarksEntry.class)),
2999 String.valueOf(PortalUtil.getClassNameId(DLFileEntry.class)),
3000 String.valueOf(PortalUtil.getClassNameId(IGImage.class)),
3001 String.valueOf(PortalUtil.getClassNameId(MBMessage.class)),
3002 String.valueOf(PortalUtil.getClassNameId(WikiPage.class)),
3003 dbUtil.getTemplateFalse(),
3004 dbUtil.getTemplateTrue()
3005 };
3006 }
3007
3008 private static final String _JSESSIONID = ";jsessionid=";
3009
3010 private static final String _LOCALHOST = "localhost";
3011
3012 private static final String _PRIVATE_GROUP_SERVLET_MAPPING =
3013 PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_GROUP_SERVLET_MAPPING;
3014
3015 private static final String _PRIVATE_USER_SERVLET_MAPPING =
3016 PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_USER_SERVLET_MAPPING;
3017
3018 private static final String _PUBLIC_GROUP_SERVLET_MAPPING =
3019 PropsValues.LAYOUT_FRIENDLY_URL_PUBLIC_SERVLET_MAPPING;
3020
3021 private static Log _log = LogFactory.getLog(PortalImpl.class);
3022
3023 private String _computerAddress;
3024 private String _computerName;
3025 private String _portalLibDir;
3026 private String _portalWebDir;
3027 private String _cdnHost;
3028 private String _pathContext;
3029 private String _pathFriendlyURLPrivateGroup;
3030 private String _pathFriendlyURLPrivateUser;
3031 private String _pathFriendlyURLPublic;
3032 private String _pathImage;
3033 private String _pathMain;
3034 private Integer _portalPort = new Integer(-1);
3035 private String[] _allSystemCommunityRoles;
3036 private String[] _allSystemGroups;
3037 private String[] _allSystemOrganizationRoles;
3038 private String[] _allSystemRoles;
3039 private String[] _sortedSystemCommunityRoles;
3040 private String[] _sortedSystemGroups;
3041 private String[] _sortedSystemOrganizationRoles;
3042 private String[] _sortedSystemRoles;
3043 private Set<String> _reservedParams;
3044 private String[] _customSqlClassNames = null;
3045 private String[] _customSqlClassNameIds = null;
3046 private Map<String, Long> _plidToPortletIdCache =
3047 new ConcurrentHashMap<String, Long>();
3048
3049}