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