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