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