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