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