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