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