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 (!themeDisplay.getServerName().equals(_LOCALHOST)) {
1047 if (Validator.isNotNull(layoutSet.getVirtualHost())) {
1048 portalURL = getPortalURL(
1049 layoutSet.getVirtualHost(), themeDisplay.getServerPort(),
1050 themeDisplay.isSecure());
1051
1052 if ((layoutSet.getLayoutSetId() != curLayoutSetId) ||
1053 (portalURL.startsWith(themeDisplay.getPortalURL()))) {
1054
1055 if (themeDisplay.isWidget()) {
1056 layoutFriendlyURL =
1057 PropsValues.WIDGET_SERVLET_MAPPING +
1058 layoutFriendlyURL;
1059 }
1060
1061 if (themeDisplay.isI18n()) {
1062 layoutFriendlyURL =
1063 StringPool.SLASH +
1064 themeDisplay.getI18nLanguageId() +
1065 layoutFriendlyURL;
1066 }
1067
1068 return portalURL + _pathContext + layoutFriendlyURL;
1069 }
1070 }
1071 else {
1072 if ((layoutSet.getLayoutSetId() != curLayoutSetId) &&
1073 (layout.getGroup().getClassPK() !=
1074 themeDisplay.getUserId())) {
1075
1076 String virtualHost =
1077 themeDisplay.getCompany().getVirtualHost();
1078
1079 if (!virtualHost.equalsIgnoreCase(_LOCALHOST)) {
1080 portalURL = getPortalURL(
1081 virtualHost, themeDisplay.getServerPort(),
1082 themeDisplay.isSecure());
1083 }
1084 }
1085 }
1086 }
1087
1088 Group group = layout.getGroup();
1089
1090 String friendlyURL = null;
1091
1092 if (layout.isPrivateLayout()) {
1093 if (group.isUser()) {
1094 friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
1095 }
1096 else {
1097 friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
1098 }
1099 }
1100 else {
1101 friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
1102 }
1103
1104 if (themeDisplay.isWidget()) {
1105 friendlyURL = PropsValues.WIDGET_SERVLET_MAPPING + friendlyURL;
1106 }
1107
1108 if (themeDisplay.isI18n()) {
1109 friendlyURL =
1110 StringPool.SLASH + themeDisplay.getI18nLanguageId() +
1111 friendlyURL;
1112 }
1113
1114 return portalURL + _pathContext + friendlyURL + group.getFriendlyURL() +
1115 layoutFriendlyURL;
1116 }
1117
1118 public String getLayoutSetFriendlyURL(
1119 LayoutSet layoutSet, ThemeDisplay themeDisplay)
1120 throws PortalException, SystemException {
1121
1122 if (Validator.isNotNull(layoutSet.getVirtualHost())) {
1123 String portalURL = getPortalURL(
1124 layoutSet.getVirtualHost(), themeDisplay.getServerPort(),
1125 themeDisplay.isSecure());
1126
1127
1130 long curLayoutSetId =
1131 themeDisplay.getLayout().getLayoutSet().getLayoutSetId();
1132
1133 if ((layoutSet.getLayoutSetId() != curLayoutSetId) ||
1134 (portalURL.startsWith(themeDisplay.getURLPortal()))) {
1135
1136 String layoutSetFriendlyURL = StringPool.BLANK;
1137
1138 if (themeDisplay.isI18n()) {
1139 layoutSetFriendlyURL =
1140 StringPool.SLASH + themeDisplay.getI18nLanguageId();
1141 }
1142
1143 return portalURL + _pathContext + layoutSetFriendlyURL;
1144 }
1145 }
1146
1147 Group group = GroupLocalServiceUtil.getGroup(layoutSet.getGroupId());
1148
1149 String friendlyURL = null;
1150
1151 if (layoutSet.isPrivateLayout()) {
1152 if (group.isUser()) {
1153 friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
1154 }
1155 else {
1156 friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
1157 }
1158 }
1159 else {
1160 friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
1161 }
1162
1163 if (themeDisplay.isI18n()) {
1164 friendlyURL =
1165 StringPool.SLASH + themeDisplay.getI18nLanguageId() +
1166 friendlyURL;
1167 }
1168
1169 return _pathContext + friendlyURL + group.getFriendlyURL();
1170 }
1171
1172 public String getLayoutTarget(Layout layout) {
1173 UnicodeProperties typeSettingsProps =
1174 layout.getTypeSettingsProperties();
1175
1176 String target = typeSettingsProps.getProperty("target");
1177
1178 if (Validator.isNull(target)) {
1179 target = StringPool.BLANK;
1180 }
1181 else {
1182 target = "target=\"" + target + "\"";
1183 }
1184
1185 return target;
1186 }
1187
1188 public String getJsSafePortletId(String portletId) {
1189 return JS.getSafeName(portletId);
1190 }
1191
1192 public Locale getLocale(HttpServletRequest request) {
1193 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
1194 WebKeys.THEME_DISPLAY);
1195
1196 if (themeDisplay != null) {
1197 return themeDisplay.getLocale();
1198 }
1199 else {
1200 HttpSession session = request.getSession();
1201
1202 return (Locale)session.getAttribute(Globals.LOCALE_KEY);
1203 }
1204 }
1205
1206 public Locale getLocale(RenderRequest renderRequest) {
1207 return getLocale(getHttpServletRequest(renderRequest));
1208 }
1209
1210 public HttpServletRequest getOriginalServletRequest(
1211 HttpServletRequest request) {
1212
1213 HttpServletRequest originalRequest = request;
1214
1215 while (originalRequest.getClass().getName().startsWith(
1216 "com.liferay.")) {
1217
1218
1221 originalRequest = (HttpServletRequest)
1222 ((HttpServletRequestWrapper)originalRequest).getRequest();
1223 }
1224
1225 return originalRequest;
1226 }
1227
1228 public String getPathContext() {
1229 return _pathContext;
1230 }
1231
1232 public String getPathFriendlyURLPrivateGroup() {
1233 return _pathFriendlyURLPrivateGroup;
1234 }
1235
1236 public String getPathFriendlyURLPrivateUser() {
1237 return _pathFriendlyURLPrivateUser;
1238 }
1239
1240 public String getPathFriendlyURLPublic() {
1241 return _pathFriendlyURLPublic;
1242 }
1243
1244 public String getPathImage() {
1245 return _pathImage;
1246 }
1247
1248 public String getPathMain() {
1249 return _pathMain;
1250 }
1251
1252 public long getPlidFromFriendlyURL(long companyId, String friendlyURL) {
1253 if (Validator.isNull(friendlyURL)) {
1254 return LayoutConstants.DEFAULT_PLID;
1255 }
1256
1257 String[] urlParts = friendlyURL.split("\\/", 4);
1258
1259 if ((friendlyURL.charAt(0) != CharPool.SLASH) &&
1260 (urlParts.length != 4)) {
1261
1262 return LayoutConstants.DEFAULT_PLID;
1263 }
1264
1265 boolean privateLayout = true;
1266
1267 String urlPrefix = StringPool.SLASH + urlParts[1];
1268
1269 if (_PUBLIC_GROUP_SERVLET_MAPPING.equals(urlPrefix)) {
1270 privateLayout = false;
1271 }
1272 else if (_PRIVATE_GROUP_SERVLET_MAPPING.equals(urlPrefix) ||
1273 _PRIVATE_USER_SERVLET_MAPPING.equals(urlPrefix)) {
1274
1275 privateLayout = true;
1276 }
1277 else {
1278 return LayoutConstants.DEFAULT_PLID;
1279 }
1280
1281 Group group = null;
1282
1283 try {
1284 group = GroupLocalServiceUtil.getFriendlyURLGroup(
1285 companyId, StringPool.SLASH + urlParts[2]);
1286 }
1287 catch (Exception e) {
1288 }
1289
1290 if (group != null) {
1291 Layout layout = null;
1292
1293 try {
1294 layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
1295 group.getGroupId(), privateLayout,
1296 StringPool.SLASH + urlParts[3]);
1297
1298 return layout.getPlid();
1299 }
1300 catch (Exception e) {
1301 }
1302 }
1303
1304 return LayoutConstants.DEFAULT_PLID;
1305 }
1306
1307 public long getPlidFromPortletId(
1308 long groupId, boolean privateLayout, String portletId) {
1309
1310 long plid = LayoutConstants.DEFAULT_PLID;
1311
1312 StringBuilder sb = new StringBuilder();
1313
1314 sb.append(groupId);
1315 sb.append(StringPool.SPACE);
1316 sb.append(privateLayout);
1317 sb.append(StringPool.SPACE);
1318 sb.append(portletId);
1319
1320 String key = sb.toString();
1321
1322 Long plidObj = _plidToPortletIdCache.get(key);
1323
1324 if (plidObj == null) {
1325 plid = _getPlidFromPortletId(groupId, privateLayout, portletId);
1326
1327 if (plid != LayoutConstants.DEFAULT_PLID) {
1328 _plidToPortletIdCache.put(key, plid);
1329 }
1330 }
1331 else {
1332 plid = plidObj.longValue();
1333
1334 boolean validPlid = false;
1335
1336 try {
1337 Layout layout = LayoutLocalServiceUtil.getLayout(plid);
1338
1339 LayoutTypePortlet layoutTypePortlet =
1340 (LayoutTypePortlet)layout.getLayoutType();
1341
1342 if (layoutTypePortlet.hasPortletId(portletId)) {
1343 validPlid = true;
1344 }
1345 }
1346 catch (Exception e) {
1347 }
1348
1349 if (!validPlid) {
1350 _plidToPortletIdCache.remove(key);
1351
1352 plid = _getPlidFromPortletId(groupId, privateLayout, portletId);
1353
1354 if (plid != LayoutConstants.DEFAULT_PLID) {
1355 _plidToPortletIdCache.put(key, plid);
1356 }
1357 }
1358 }
1359
1360 return plid;
1361 }
1362
1363 public String getPortalLibDir() {
1364 return _portalLibDir;
1365 }
1366
1367 public int getPortalPort() {
1368 return _portalPort.intValue();
1369 }
1370
1371 public Properties getPortalProperties() {
1372 return PropsUtil.getProperties();
1373 }
1374
1375 public String getPortalURL(ThemeDisplay themeDisplay) {
1376 String serverName = themeDisplay.getServerName();
1377
1378 Layout layout = themeDisplay.getLayout();
1379
1380 if (layout != null) {
1381 LayoutSet layoutSet = layout.getLayoutSet();
1382
1383 if (Validator.isNotNull(layoutSet.getVirtualHost())) {
1384 serverName = layoutSet.getVirtualHost();
1385 }
1386 }
1387
1388 return getPortalURL(
1389 serverName, themeDisplay.getServerPort(), themeDisplay.isSecure());
1390 }
1391
1392 public String getPortalURL(HttpServletRequest request) {
1393 return getPortalURL(request, request.isSecure());
1394 }
1395
1396 public String getPortalURL(HttpServletRequest request, boolean secure) {
1397 return getPortalURL(
1398 request.getServerName(), request.getServerPort(), secure);
1399 }
1400
1401 public String getPortalURL(PortletRequest portletRequest) {
1402 return getPortalURL(portletRequest, portletRequest.isSecure());
1403 }
1404
1405 public String getPortalURL(PortletRequest portletRequest, boolean secure) {
1406 return getPortalURL(
1407 portletRequest.getServerName(), portletRequest.getServerPort(),
1408 secure);
1409 }
1410
1411 public String getPortalURL(
1412 String serverName, int serverPort, boolean secure) {
1413
1414 StringBuilder sb = new StringBuilder();
1415
1416 if (secure || Http.HTTPS.equals(PropsValues.WEB_SERVER_PROTOCOL)) {
1417 sb.append(Http.HTTPS_WITH_SLASH);
1418 }
1419 else {
1420 sb.append(Http.HTTP_WITH_SLASH);
1421 }
1422
1423 if (Validator.isNull(PropsValues.WEB_SERVER_HOST)) {
1424 sb.append(serverName);
1425 }
1426 else {
1427 sb.append(PropsValues.WEB_SERVER_HOST);
1428 }
1429
1430 if (!secure) {
1431 if (PropsValues.WEB_SERVER_HTTP_PORT == -1) {
1432 if ((serverPort != Http.HTTP_PORT) &&
1433 (serverPort != Http.HTTPS_PORT)) {
1434
1435 sb.append(StringPool.COLON);
1436 sb.append(serverPort);
1437 }
1438 }
1439 else {
1440 if ((PropsValues.WEB_SERVER_HTTP_PORT != serverPort) &&
1441 (PropsValues.WEB_SERVER_HTTP_PORT != Http.HTTP_PORT)) {
1442
1443 sb.append(StringPool.COLON);
1444 sb.append(PropsValues.WEB_SERVER_HTTP_PORT);
1445 }
1446 }
1447 }
1448
1449 if (secure) {
1450 if (PropsValues.WEB_SERVER_HTTPS_PORT == -1) {
1451 if ((serverPort != Http.HTTP_PORT) &&
1452 (serverPort != Http.HTTPS_PORT)) {
1453
1454 sb.append(StringPool.COLON);
1455 sb.append(serverPort);
1456 }
1457 }
1458 else {
1459 if ((PropsValues.WEB_SERVER_HTTPS_PORT != serverPort) &&
1460 (PropsValues.WEB_SERVER_HTTPS_PORT != Http.HTTPS_PORT)) {
1461
1462 sb.append(StringPool.COLON);
1463 sb.append(PropsValues.WEB_SERVER_HTTPS_PORT);
1464 }
1465 }
1466 }
1467
1468 return sb.toString();
1469 }
1470
1471 public String getPortalWebDir() {
1472 return _portalWebDir;
1473 }
1474
1475 public Object[] getPortletFriendlyURLMapper(
1476 long groupId, boolean privateLayout, String url)
1477 throws PortalException, SystemException {
1478
1479 return getPortletFriendlyURLMapper(groupId, privateLayout, url, null);
1480 }
1481
1482 public Object[] getPortletFriendlyURLMapper(
1483 long groupId, boolean privateLayout, String url,
1484 Map<String, String[]> params)
1485 throws PortalException, SystemException {
1486
1487 boolean foundFriendlyURLMapper = false;
1488
1489 String friendlyURL = url;
1490 String queryString = StringPool.BLANK;
1491
1492 List<FriendlyURLMapper> friendlyURLMappers =
1493 PortletLocalServiceUtil.getFriendlyURLMappers();
1494
1495 Iterator<FriendlyURLMapper> itr = friendlyURLMappers.iterator();
1496
1497 while (itr.hasNext()) {
1498 FriendlyURLMapper friendlyURLMapper = itr.next();
1499
1500 if (url.endsWith(
1501 StringPool.SLASH + friendlyURLMapper.getMapping())) {
1502
1503 url += StringPool.SLASH;
1504 }
1505
1506 int pos = -1;
1507
1508 if (friendlyURLMapper.isCheckMappingWithPrefix()) {
1509 pos = url.indexOf(
1510 "/-/" + friendlyURLMapper.getMapping() + StringPool.SLASH);
1511 }
1512 else {
1513 pos = url.indexOf(
1514 StringPool.SLASH + friendlyURLMapper.getMapping() +
1515 StringPool.SLASH);
1516 }
1517
1518 if (pos != -1) {
1519 foundFriendlyURLMapper = true;
1520
1521 friendlyURL = url.substring(0, pos);
1522
1523 Map<String, String[]> actualParams = null;
1524
1525 if (params != null) {
1526 actualParams = new HashMap<String, String[]>(params);
1527 }
1528 else {
1529 actualParams = new HashMap<String, String[]>();
1530 }
1531
1532
1546
1547 if (friendlyURLMapper.isCheckMappingWithPrefix()) {
1548 friendlyURLMapper.populateParams(
1549 url.substring(pos + 2), actualParams);
1550 }
1551 else {
1552 friendlyURLMapper.populateParams(
1553 url.substring(pos), actualParams);
1554 }
1555
1556 queryString =
1557 StringPool.AMPERSAND +
1558 HttpUtil.parameterMapToString(actualParams, false);
1559
1560 break;
1561 }
1562 }
1563
1564 if (!foundFriendlyURLMapper) {
1565 int x = url.indexOf("/-/");
1566
1567 if (x != -1) {
1568 int y = url.indexOf(StringPool.SLASH, x + 3);
1569
1570 if (y == -1) {
1571 y = url.length();
1572 }
1573
1574 String ppid = url.substring(x + 3, y);
1575
1576 if (Validator.isNotNull(ppid)) {
1577 friendlyURL = url.substring(0, x);
1578
1579 Map<String, String[]> actualParams = null;
1580
1581 if (params != null) {
1582 actualParams = new HashMap<String, String[]>(params);
1583 }
1584 else {
1585 actualParams = new HashMap<String, String[]>();
1586 }
1587
1588 actualParams.put("p_p_id", new String[] {ppid});
1589 actualParams.put("p_p_lifecycle", new String[] {"0"});
1590 actualParams.put(
1591 "p_p_state",
1592 new String[] {WindowState.MAXIMIZED.toString()});
1593 actualParams.put(
1594 "p_p_mode", new String[] {PortletMode.VIEW.toString()});
1595
1596 queryString =
1597 StringPool.AMPERSAND +
1598 HttpUtil.parameterMapToString(actualParams, false);
1599 }
1600 }
1601 }
1602
1603 friendlyURL = StringUtil.replace(
1604 friendlyURL, StringPool.DOUBLE_SLASH, StringPool.SLASH);
1605
1606 if (friendlyURL.endsWith(StringPool.SLASH)) {
1607 friendlyURL = friendlyURL.substring(0, friendlyURL.length() - 1);
1608 }
1609
1610 Layout layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
1611 groupId, privateLayout, friendlyURL);
1612
1613 return new Object[] {layout, queryString};
1614 }
1615
1616
1619 public long getPortletGroupId(long plid) {
1620 Layout layout = null;
1621
1622 try {
1623 layout = LayoutLocalServiceUtil.getLayout(plid);
1624 }
1625 catch (Exception e) {
1626 }
1627
1628 return getPortletGroupId(layout);
1629 }
1630
1631
1634 public long getPortletGroupId(Layout layout) {
1635 return getScopeGroupId(layout);
1636 }
1637
1638
1641 public long getPortletGroupId(HttpServletRequest request) {
1642 return getScopeGroupId(request);
1643 }
1644
1645
1648 public long getPortletGroupId(ActionRequest actionRequest) {
1649 return getScopeGroupId(actionRequest);
1650 }
1651
1652
1655 public long getPortletGroupId(RenderRequest renderRequest) {
1656 return getScopeGroupId(renderRequest);
1657 }
1658
1659 public String getPortletId(HttpServletRequest request) {
1660 PortletConfigImpl portletConfigImpl =
1661 (PortletConfigImpl)request.getAttribute(
1662 JavaConstants.JAVAX_PORTLET_CONFIG);
1663
1664 if (portletConfigImpl != null) {
1665 return portletConfigImpl.getPortletId();
1666 }
1667 else {
1668 return null;
1669 }
1670 }
1671
1672 public String getPortletId(PortletRequest portletRequest) {
1673 PortletConfigImpl portletConfigImpl =
1674 (PortletConfigImpl)portletRequest.getAttribute(
1675 JavaConstants.JAVAX_PORTLET_CONFIG);
1676
1677 if (portletConfigImpl != null) {
1678 return portletConfigImpl.getPortletId();
1679 }
1680 else {
1681 return null;
1682 }
1683 }
1684
1685 public String getPortletNamespace(String portletId) {
1686 StringBuilder sb = new StringBuilder();
1687
1688 sb.append(StringPool.UNDERLINE);
1689 sb.append(portletId);
1690 sb.append(StringPool.UNDERLINE);
1691
1692 return sb.toString();
1693 }
1694
1695 public String getPortletTitle(
1696 String portletId, long companyId, String languageId) {
1697
1698 Locale locale = LocaleUtil.fromLanguageId(languageId);
1699
1700 return getPortletTitle(portletId, companyId, locale);
1701 }
1702
1703 public String getPortletTitle(
1704 String portletId, long companyId, Locale locale) {
1705
1706 StringBuilder sb = new StringBuilder();
1707
1708 sb.append(JavaConstants.JAVAX_PORTLET_TITLE);
1709 sb.append(StringPool.PERIOD);
1710 sb.append(portletId);
1711
1712 return LanguageUtil.get(companyId, locale, sb.toString());
1713 }
1714
1715 public String getPortletTitle(String portletId, User user) {
1716 StringBuilder sb = new StringBuilder();
1717
1718 sb.append(JavaConstants.JAVAX_PORTLET_TITLE);
1719 sb.append(StringPool.PERIOD);
1720 sb.append(portletId);
1721
1722 return LanguageUtil.get(
1723 user.getCompanyId(), user.getLocale(), sb.toString());
1724 }
1725
1726 public String getPortletTitle(
1727 Portlet portlet, long companyId, String languageId) {
1728
1729 return getPortletTitle(portlet.getPortletId(), companyId, languageId);
1730 }
1731
1732 public String getPortletTitle(
1733 Portlet portlet, long companyId, Locale locale) {
1734
1735 return getPortletTitle(portlet.getPortletId(), companyId, locale);
1736 }
1737
1738 public String getPortletTitle(Portlet portlet, User user) {
1739 return getPortletTitle(portlet.getPortletId(), user);
1740 }
1741
1742 public String getPortletTitle(
1743 Portlet portlet, ServletContext servletContext, Locale locale) {
1744
1745 PortletConfig portletConfig = PortletConfigFactory.create(
1746 portlet, servletContext);
1747
1748 ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
1749
1750 return resourceBundle.getString(JavaConstants.JAVAX_PORTLET_TITLE);
1751 }
1752
1753 public String getPortletXmlFileName() throws SystemException {
1754 if (PrefsPropsUtil.getBoolean(
1755 PropsKeys.AUTO_DEPLOY_CUSTOM_PORTLET_XML,
1756 PropsValues.AUTO_DEPLOY_CUSTOM_PORTLET_XML)) {
1757
1758 return PORTLET_XML_FILE_NAME_CUSTOM;
1759 }
1760 else {
1761 return PORTLET_XML_FILE_NAME_STANDARD;
1762 }
1763 }
1764
1765 public PortletPreferences getPreferences(HttpServletRequest request) {
1766 RenderRequest renderRequest = (RenderRequest)request.getAttribute(
1767 JavaConstants.JAVAX_PORTLET_REQUEST);
1768
1769 PortletPreferences preferences = null;
1770
1771 if (renderRequest != null) {
1772 PortletPreferencesWrapper preferencesWrapper =
1773 (PortletPreferencesWrapper)renderRequest.getPreferences();
1774
1775 preferences = preferencesWrapper.getPreferencesImpl();
1776 }
1777
1778 return preferences;
1779 }
1780
1781 public PreferencesValidator getPreferencesValidator(Portlet portlet) {
1782 PortletApp portletApp = portlet.getPortletApp();
1783
1784 if (portletApp.isWARFile()) {
1785 PortletBag portletBag = PortletBagPool.get(
1786 portlet.getRootPortletId());
1787
1788 return portletBag.getPreferencesValidatorInstance();
1789 }
1790 else {
1791 PreferencesValidator preferencesValidator = null;
1792
1793 if (Validator.isNotNull(portlet.getPreferencesValidator())) {
1794 preferencesValidator =
1795 (PreferencesValidator)InstancePool.get(
1796 portlet.getPreferencesValidator());
1797 }
1798
1799 return preferencesValidator;
1800 }
1801 }
1802
1803 public long getScopeGroupId(long plid) {
1804 Layout layout = null;
1805
1806 try {
1807 layout = LayoutLocalServiceUtil.getLayout(plid);
1808 }
1809 catch (Exception e) {
1810 }
1811
1812 return getScopeGroupId(layout);
1813 }
1814
1815 public long getScopeGroupId(Layout layout) {
1816 if (layout == null) {
1817 return 0;
1818 }
1819 else {
1820 return layout.getGroupId();
1821 }
1822 }
1823
1824 public long getScopeGroupId(Layout layout, String portletId) {
1825 if (layout == null) {
1826 return 0;
1827 }
1828 else {
1829 if (Validator.isNotNull(portletId)) {
1830 try {
1831 PortletPreferences portletSetup =
1832 PortletPreferencesFactoryUtil.getLayoutPortletSetup(
1833 layout, portletId);
1834
1835 long scopeLayoutId = GetterUtil.getLong(
1836 portletSetup.getValue("lfr-scope-layout-id", null));
1837
1838 if (scopeLayoutId > 0) {
1839 Layout scopeLayout = LayoutLocalServiceUtil.getLayout(
1840 layout.getGroupId(), layout.isPrivateLayout(),
1841 scopeLayoutId);
1842
1843 return scopeLayout.getScopeGroup().getGroupId();
1844 }
1845 }
1846 catch (Exception e) {
1847 }
1848 }
1849
1850 return layout.getGroupId();
1851 }
1852 }
1853
1854 public long getScopeGroupId(HttpServletRequest request) {
1855 String portletId = getPortletId(request);
1856
1857 return getScopeGroupId(request, portletId);
1858 }
1859
1860 public long getScopeGroupId(HttpServletRequest request, String portletId) {
1861 Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
1862
1863 long scopeGroupId = 0;
1864
1865 if (layout != null) {
1866 Group group = layout.getGroup();
1867
1868 if (group.getName().equals(GroupConstants.CONTROL_PANEL)) {
1869 long doAsGroupId = ParamUtil.getLong(request, "doAsGroupId");
1870
1871 if (doAsGroupId <= 0) {
1872 try {
1873 Group guestGroup = GroupLocalServiceUtil.getGroup(
1874 group.getCompanyId(), GroupConstants.GUEST);
1875
1876 doAsGroupId = guestGroup.getGroupId();
1877 }
1878 catch (Exception e) {
1879 }
1880 }
1881
1882 if (doAsGroupId > 0) {
1883 scopeGroupId = doAsGroupId;
1884 }
1885 }
1886 }
1887
1888 if (scopeGroupId <= 0) {
1889 scopeGroupId = getScopeGroupId(layout, portletId);
1890 }
1891
1892 return scopeGroupId;
1893 }
1894
1895 public long getScopeGroupId(PortletRequest portletRequest) {
1896 return getScopeGroupId(getHttpServletRequest(portletRequest));
1897 }
1898
1899 public User getSelectedUser(HttpServletRequest request)
1900 throws PortalException, SystemException {
1901
1902 return getSelectedUser(request, true);
1903 }
1904
1905 public User getSelectedUser(
1906 HttpServletRequest request, boolean checkPermission)
1907 throws PortalException, SystemException {
1908
1909 long userId = ParamUtil.getLong(request, "p_u_i_d");
1910
1911 User user = null;
1912
1913 try {
1914 if (checkPermission) {
1915 user = UserServiceUtil.getUserById(userId);
1916 }
1917 else {
1918 user = UserLocalServiceUtil.getUserById(userId);
1919 }
1920 }
1921 catch (NoSuchUserException nsue) {
1922 }
1923
1924 return user;
1925 }
1926
1927 public User getSelectedUser(PortletRequest portletRequest)
1928 throws PortalException, SystemException {
1929
1930 return getSelectedUser(portletRequest, true);
1931 }
1932
1933 public User getSelectedUser(
1934 PortletRequest portletRequest, boolean checkPermission)
1935 throws PortalException, SystemException {
1936
1937 return getSelectedUser(
1938 getHttpServletRequest(portletRequest), checkPermission);
1939 }
1940
1941 public String getStaticResourceURL(
1942 HttpServletRequest request, String uri) {
1943
1944 return getStaticResourceURL(request, uri, null, 0);
1945 }
1946
1947 public String getStaticResourceURL(
1948 HttpServletRequest request, String uri, String queryString) {
1949
1950 return getStaticResourceURL(request, uri, queryString, 0);
1951 }
1952
1953 public String getStaticResourceURL(
1954 HttpServletRequest request, String uri, long timestamp) {
1955
1956 return getStaticResourceURL(request, uri, null, timestamp);
1957 }
1958
1959 public String getStaticResourceURL(
1960 HttpServletRequest request, String uri, String queryString,
1961 long timestamp) {
1962
1963 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
1964 WebKeys.THEME_DISPLAY);
1965
1966 Theme theme = themeDisplay.getTheme();
1967 ColorScheme colorScheme = themeDisplay.getColorScheme();
1968
1969 Map<String, String[]> parameterMap = null;
1970
1971 if (Validator.isNotNull(queryString)) {
1972 parameterMap = HttpUtil.getParameterMap(queryString);
1973 }
1974
1975 StringBuilder sb = new StringBuilder();
1976
1977
1979 sb.append(uri);
1980 sb.append(StringPool.QUESTION);
1981
1982
1984 if ((parameterMap == null) ||
1985 (!parameterMap.containsKey("browserId"))) {
1986
1987 sb.append("&browserId=");
1988 sb.append(BrowserSnifferUtil.getBrowserId(request));
1989 }
1990
1991
1993 if (uri.endsWith(".jsp")) {
1994 if ((parameterMap == null) ||
1995 (!parameterMap.containsKey("themeId"))) {
1996
1997 sb.append("&themeId=");
1998 sb.append(theme.getThemeId());
1999 }
2000
2001 if ((parameterMap == null) ||
2002 (!parameterMap.containsKey("colorSchemeId"))) {
2003
2004 sb.append("&colorSchemeId=");
2005 sb.append(colorScheme.getColorSchemeId());
2006 }
2007 }
2008
2009
2011 if (themeDisplay.isThemeCssFastLoad()) {
2012 if ((parameterMap == null) ||
2013 (!parameterMap.containsKey("minifierType"))) {
2014
2015 String minifierType = "js";
2016
2017 if (uri.endsWith(".css") || uri.endsWith("css.jsp")) {
2018 minifierType = "css";
2019 }
2020
2021 sb.append("&minifierType=");
2022 sb.append(minifierType);
2023 }
2024 }
2025
2026
2028 if (Validator.isNotNull(queryString)) {
2029 if (!queryString.startsWith(StringPool.AMPERSAND)) {
2030 sb.append(StringPool.AMPERSAND);
2031 }
2032
2033 sb.append(queryString);
2034 }
2035
2036
2038 if ((parameterMap == null) || (!parameterMap.containsKey("t"))) {
2039 sb.append("&t=");
2040 sb.append(theme.getTimestamp());
2041 }
2042
2043 String url = sb.toString();
2044
2045 url = StringUtil.replace(url, "?&", StringPool.QUESTION);
2046
2047 return url;
2048 }
2049
2050 public String getStrutsAction(HttpServletRequest request) {
2051 String strutsAction = ParamUtil.getString(request, "struts_action");
2052
2053 if (Validator.isNotNull(strutsAction)) {
2054
2055
2059 return StringPool.BLANK;
2060 }
2061
2062 return _getPortletParam(request, "struts_action");
2063 }
2064
2065 public String[] getSystemCommunityRoles() {
2066 return _allSystemCommunityRoles;
2067 }
2068
2069 public String[] getSystemGroups() {
2070 return _allSystemGroups;
2071 }
2072
2073 public String[] getSystemOrganizationRoles() {
2074 return _allSystemOrganizationRoles;
2075 }
2076
2077 public String[] getSystemRoles() {
2078 return _allSystemRoles;
2079 }
2080
2081 public String[] getTagsCategories(PortletRequest portletRequest) {
2082 return TagsUtil.getTagsCategories(portletRequest);
2083 }
2084
2085 public String[] getTagsEntries(PortletRequest portletRequest) {
2086 return TagsUtil.getTagsEntries(portletRequest);
2087 }
2088
2089 public UploadPortletRequest getUploadPortletRequest(
2090 ActionRequest actionRequest) {
2091
2092 if (actionRequest instanceof ActionRequestImpl) {
2093 ActionRequestImpl actionRequestImpl =
2094 (ActionRequestImpl)actionRequest;
2095
2096 DynamicServletRequest dynamicRequest =
2097 (DynamicServletRequest)
2098 actionRequestImpl.getHttpServletRequest();
2099
2100 HttpServletRequestWrapper requestWrapper =
2101 (HttpServletRequestWrapper)dynamicRequest.getRequest();
2102
2103 UploadServletRequest uploadRequest = getUploadServletRequest(
2104 requestWrapper);
2105
2106 return new UploadPortletRequestImpl(
2107 uploadRequest,
2108 PortalUtil.getPortletNamespace(
2109 actionRequestImpl.getPortletName()));
2110
2111 }
2112 else {
2113
2114 com.sun.portal.portletcontainer.portlet.impl.ActionRequestImpl
2115 actionRequestImpl =
2116 (com.sun.portal.portletcontainer.portlet.impl.ActionRequestImpl)
2117 actionRequest;
2118
2119 HttpServletRequestWrapper requestWrapper =
2120 (HttpServletRequestWrapper)
2121 actionRequestImpl.getHttpServletRequest();
2122
2123 UploadServletRequest uploadRequest = getUploadServletRequest(
2124 requestWrapper);
2125
2126 String portletWindowName = (String)actionRequest.getAttribute(
2127 "javax.portlet.portletc.portletWindowName");
2128
2129 return new UploadPortletRequestImpl(
2130 uploadRequest,
2131 PortalUtil.getPortletNamespace(portletWindowName));
2132 }
2133
2134 }
2135
2136 public UploadServletRequest getUploadServletRequest(
2137 HttpServletRequest request) {
2138
2139 HttpServletRequestWrapper requestWrapper = null;
2140
2141 if (request instanceof HttpServletRequestWrapper) {
2142 requestWrapper = (HttpServletRequestWrapper)request;
2143 }
2144
2145 UploadServletRequest uploadRequest = null;
2146
2147 while (uploadRequest == null) {
2148
2149
2152 if (requestWrapper instanceof UploadServletRequest) {
2153 uploadRequest = (UploadServletRequest)requestWrapper;
2154 }
2155 else {
2156 HttpServletRequest parentRequest =
2157 (HttpServletRequest)requestWrapper.getRequest();
2158
2159 if (!(parentRequest instanceof HttpServletRequestWrapper)) {
2160
2161
2164 uploadRequest = new UploadServletRequestImpl(parentRequest);
2165
2166 break;
2167 }
2168 else {
2169 requestWrapper = (HttpServletRequestWrapper)parentRequest;
2170 }
2171 }
2172 }
2173
2174 return uploadRequest;
2175 }
2176
2177 public Date getUptime() {
2178 return UP_TIME;
2179 }
2180
2181 public String getURLWithSessionId(String url, String sessionId) {
2182 if (!PropsValues.SESSION_ENABLE_URL_WITH_SESSION_ID) {
2183 return url;
2184 }
2185
2186
2188 int x = url.indexOf(StringPool.SEMICOLON);
2189
2190 if (x != -1) {
2191 return url;
2192 }
2193
2194 x = url.indexOf(StringPool.QUESTION);
2195
2196 if (x != -1) {
2197 StringBuilder sb = new StringBuilder();
2198
2199 sb.append(url.substring(0, x));
2200 sb.append(_JSESSIONID);
2201 sb.append(sessionId);
2202 sb.append(url.substring(x));
2203
2204 return sb.toString();
2205 }
2206
2207
2210 x = url.indexOf(StringPool.DOUBLE_SLASH);
2211
2212 StringBuilder sb = new StringBuilder();
2213
2214 sb.append(url);
2215
2216 if (x != -1) {
2217 int y = url.lastIndexOf(StringPool.SLASH);
2218
2219 if (x + 1 == y) {
2220 sb.append(StringPool.SLASH);
2221 }
2222 }
2223
2224 sb.append(_JSESSIONID);
2225 sb.append(sessionId);
2226
2227 return sb.toString();
2228 }
2229
2230 public User getUser(HttpServletRequest request)
2231 throws PortalException, SystemException {
2232
2233 long userId = getUserId(request);
2234
2235 if (userId <= 0) {
2236
2237
2242 String remoteUser = request.getRemoteUser();
2243
2244 if (remoteUser == null) {
2245 return null;
2246 }
2247
2248 userId = GetterUtil.getLong(remoteUser);
2249 }
2250
2251 User user = (User)request.getAttribute(WebKeys.USER);
2252
2253 if (user == null) {
2254 user = UserLocalServiceUtil.getUserById(userId);
2255
2256 request.setAttribute(WebKeys.USER, user);
2257 }
2258
2259 return user;
2260 }
2261
2262 public User getUser(PortletRequest portletRequest)
2263 throws PortalException, SystemException {
2264
2265 return getUser(getHttpServletRequest(portletRequest));
2266 }
2267
2268 public long getUserId(HttpServletRequest request) {
2269 Long userIdObj = (Long)request.getAttribute(WebKeys.USER_ID);
2270
2271 if (userIdObj != null) {
2272 return userIdObj.longValue();
2273 }
2274
2275 String path = GetterUtil.getString(request.getPathInfo());
2276 String strutsAction = getStrutsAction(request);
2277 String actionName = _getPortletParam(request, "actionName");
2278
2279 boolean alwaysAllowDoAsUser = false;
2280
2281 if (path.equals("/portal/fckeditor") ||
2282 strutsAction.equals("/document_library/edit_file_entry") ||
2283 strutsAction.equals("/image_gallery/edit_image") ||
2284 strutsAction.equals("/wiki/edit_page_attachment") ||
2285 actionName.equals("addFile")) {
2286
2287 alwaysAllowDoAsUser = true;
2288 }
2289
2290 if ((!PropsValues.PORTAL_JAAS_ENABLE &&
2291 PropsValues.PORTAL_IMPERSONATION_ENABLE) ||
2292 (alwaysAllowDoAsUser)) {
2293
2294 String doAsUserIdString = ParamUtil.getString(
2295 request, "doAsUserId");
2296
2297 try {
2298 long doAsUserId = getDoAsUserId(
2299 request, doAsUserIdString, alwaysAllowDoAsUser);
2300
2301 if (doAsUserId > 0) {
2302 if (_log.isDebugEnabled()) {
2303 _log.debug("Impersonating user " + doAsUserId);
2304 }
2305
2306 return doAsUserId;
2307 }
2308 }
2309 catch (Exception e) {
2310 _log.error("Unable to impersonate user " + doAsUserIdString, e);
2311 }
2312 }
2313
2314 HttpSession session = request.getSession();
2315
2316 userIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
2317
2318 if (userIdObj != null) {
2319 request.setAttribute(WebKeys.USER_ID, userIdObj);
2320
2321 return userIdObj.longValue();
2322 }
2323 else {
2324 return 0;
2325 }
2326 }
2327
2328 public long getUserId(PortletRequest portletRequest) {
2329 return getUserId(getHttpServletRequest(portletRequest));
2330 }
2331
2332 public String getUserName(long userId, String defaultUserName) {
2333 return getUserName(
2334 userId, defaultUserName, UserAttributes.USER_NAME_FULL);
2335 }
2336
2337 public String getUserName(
2338 long userId, String defaultUserName, String userAttribute) {
2339
2340 return getUserName(userId, defaultUserName, userAttribute, null);
2341 }
2342
2343 public String getUserName(
2344 long userId, String defaultUserName, HttpServletRequest request) {
2345
2346 return getUserName(
2347 userId, defaultUserName, UserAttributes.USER_NAME_FULL, request);
2348 }
2349
2350 public String getUserName(
2351 long userId, String defaultUserName, String userAttribute,
2352 HttpServletRequest request) {
2353
2354 String userName = defaultUserName;
2355
2356 try {
2357 User user = UserLocalServiceUtil.getUserById(userId);
2358
2359 if (userAttribute.equals(UserAttributes.USER_NAME_FULL)) {
2360 userName = user.getFullName();
2361 }
2362 else {
2363 userName = user.getScreenName();
2364 }
2365
2366 if (request != null) {
2367 Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
2368
2369 PortletURL portletURL = new PortletURLImpl(
2370 request, PortletKeys.DIRECTORY, layout.getPlid(),
2371 PortletRequest.RENDER_PHASE);
2372
2373 portletURL.setWindowState(WindowState.MAXIMIZED);
2374 portletURL.setPortletMode(PortletMode.VIEW);
2375
2376 portletURL.setParameter(
2377 "struts_action", "/directory/view_user");
2378 portletURL.setParameter(
2379 "p_u_i_d", String.valueOf(user.getUserId()));
2380
2381 userName =
2382 "<a href=\"" + portletURL.toString() + "\">" + userName +
2383 "</a>";
2384 }
2385 }
2386 catch (Exception e) {
2387 }
2388
2389 return userName;
2390 }
2391
2392 public String getUserPassword(HttpSession session) {
2393 return (String)session.getAttribute(WebKeys.USER_PASSWORD);
2394 }
2395
2396 public String getUserPassword(HttpServletRequest request) {
2397 HttpSession session = request.getSession();
2398
2399 return getUserPassword(session);
2400 }
2401
2402 public String getUserPassword(PortletRequest portletRequest) {
2403 return getUserPassword(getHttpServletRequest(portletRequest));
2404 }
2405
2406 public String getUserValue(long userId, String param, String defaultValue)
2407 throws SystemException {
2408
2409 if (Validator.isNotNull(defaultValue)) {
2410 return defaultValue;
2411 }
2412 else {
2413 try {
2414 User user = UserLocalServiceUtil.getUserById(userId);
2415
2416 return BeanPropertiesUtil.getString(user, param, defaultValue);
2417 }
2418 catch (PortalException pe) {
2419 return StringPool.BLANK;
2420 }
2421 }
2422 }
2423
2424 public String getWidgetURL(Portlet portlet, ThemeDisplay themeDisplay) {
2425 String layoutURL = getLayoutURL(themeDisplay);
2426
2427 Layout layout = themeDisplay.getLayout();
2428
2429 StringBuilder sb = new StringBuilder();
2430
2431 if (HttpUtil.hasDomain(layoutURL)) {
2432 String protocol = HttpUtil.getProtocol(layoutURL);
2433 String domain = HttpUtil.getDomain(layoutURL);
2434 HttpUtil.removeDomain(layoutURL);
2435
2436 sb.append(protocol);
2437 sb.append(Http.PROTOCOL_DELIMITER);
2438 sb.append(domain);
2439
2440 if (Validator.isNotNull(_pathContext)) {
2441 sb.append(_pathContext);
2442 }
2443
2444 if (themeDisplay.isI18n()) {
2445 sb.append(StringPool.SLASH);
2446 sb.append(themeDisplay.getI18nLanguageId());
2447 }
2448
2449 sb.append(PropsValues.WIDGET_SERVLET_MAPPING);
2450 sb.append(layout.getFriendlyURL());
2451 }
2452 else {
2453 sb.append(themeDisplay.getPortalURL());
2454
2455 if (Validator.isNotNull(_pathContext)) {
2456 sb.append(_pathContext);
2457 }
2458
2459 if (themeDisplay.isI18n()) {
2460 sb.append(StringPool.SLASH);
2461 sb.append(themeDisplay.getI18nLanguageId());
2462 }
2463
2464 sb.append(PropsValues.WIDGET_SERVLET_MAPPING);
2465
2466 Group group = layout.getGroup();
2467
2468 if (layout.isPrivateLayout()) {
2469 if (group.isUser()) {
2470 sb.append(_PRIVATE_USER_SERVLET_MAPPING);
2471 }
2472 else {
2473 sb.append(_PRIVATE_GROUP_SERVLET_MAPPING);
2474 }
2475 }
2476 else {
2477 sb.append(_PUBLIC_GROUP_SERVLET_MAPPING);
2478 }
2479
2480 sb.append(group.getFriendlyURL());
2481 sb.append(layout.getFriendlyURL());
2482 }
2483
2484 sb.append("/-/");
2485
2486 FriendlyURLMapper friendlyURLMapper =
2487 portlet.getFriendlyURLMapperInstance();
2488
2489 if ((friendlyURLMapper != null) && !portlet.isInstanceable()) {
2490 sb.append(friendlyURLMapper.getMapping());
2491 }
2492 else {
2493 sb.append(portlet.getPortletId());
2494 }
2495
2496 return sb.toString();
2497 }
2498
2499 public boolean isLayoutFirstPageable(String type) {
2500 return GetterUtil.getBoolean(
2501 PropsUtil.get(PropsKeys.LAYOUT_FIRST_PAGEABLE, new Filter(type)),
2502 false);
2503 }
2504
2505 public boolean isLayoutFriendliable(Layout layout) {
2506 return GetterUtil.getBoolean(
2507 PropsUtil.get(
2508 PropsKeys.LAYOUT_URL_FRIENDLIABLE,
2509 new Filter(layout.getType())),
2510 true);
2511 }
2512
2513 public boolean isLayoutParentable(Layout layout) {
2514 return isLayoutParentable(layout.getType());
2515 }
2516
2517 public boolean isLayoutParentable(String type) {
2518 return GetterUtil.getBoolean(
2519 PropsUtil.get(PropsKeys.LAYOUT_PARENTABLE, new Filter(type)), true);
2520 }
2521
2522 public boolean isLayoutSitemapable(Layout layout) {
2523 if (layout.isPrivateLayout()) {
2524 return false;
2525 }
2526
2527 return GetterUtil.getBoolean(PropsUtil.get(
2528 PropsKeys.LAYOUT_SITEMAPABLE, new Filter(layout.getType())), true);
2529 }
2530
2531 public boolean isMethodGet(PortletRequest portletRequest) {
2532 HttpServletRequest request = getHttpServletRequest(portletRequest);
2533
2534 String method = GetterUtil.getString(request.getMethod());
2535
2536 if (method.equalsIgnoreCase(HttpMethods.GET)) {
2537 return true;
2538 }
2539 else {
2540 return false;
2541 }
2542 }
2543
2544 public boolean isMethodPost(PortletRequest portletRequest) {
2545 HttpServletRequest request = getHttpServletRequest(portletRequest);
2546
2547 String method = GetterUtil.getString(request.getMethod());
2548
2549 if (method.equalsIgnoreCase(HttpMethods.POST)) {
2550 return true;
2551 }
2552 else {
2553 return false;
2554 }
2555 }
2556
2557 public boolean isReservedParameter(String name) {
2558 return _reservedParams.contains(name);
2559 }
2560
2561 public boolean isSystemGroup(String groupName) {
2562 if (groupName == null) {
2563 return false;
2564 }
2565
2566 groupName = groupName.trim();
2567
2568 int pos = Arrays.binarySearch(
2569 _sortedSystemGroups, groupName, new StringComparator());
2570
2571 if (pos >= 0) {
2572 return true;
2573 }
2574 else {
2575 return false;
2576 }
2577 }
2578
2579 public boolean isSystemRole(String roleName) {
2580 if (roleName == null) {
2581 return false;
2582 }
2583
2584 roleName = roleName.trim();
2585
2586 int pos = Arrays.binarySearch(
2587 _sortedSystemRoles, roleName, new StringComparator());
2588
2589 if (pos >= 0) {
2590 return true;
2591 }
2592 else {
2593 pos = Arrays.binarySearch(
2594 _sortedSystemCommunityRoles, roleName, new StringComparator());
2595
2596 if (pos >= 0) {
2597 return true;
2598 }
2599 else {
2600 pos = Arrays.binarySearch(
2601 _sortedSystemOrganizationRoles, roleName,
2602 new StringComparator());
2603
2604 if (pos >= 0) {
2605 return true;
2606 }
2607 }
2608 }
2609
2610 return false;
2611 }
2612
2613 public boolean isUpdateAvailable()
2614 throws PortalException, SystemException {
2615
2616 return PluginPackageUtil.isUpdateAvailable();
2617 }
2618
2619 public void renderPage(
2620 StringBuilder sb, ServletContext servletContext,
2621 HttpServletRequest request, HttpServletResponse response,
2622 String path)
2623 throws IOException, ServletException {
2624
2625 RequestDispatcher requestDispatcher =
2626 servletContext.getRequestDispatcher(path);
2627
2628 StringServletResponse stringResponse = new StringServletResponse(
2629 response);
2630
2631 requestDispatcher.include(request, stringResponse);
2632
2633 sb.append(stringResponse.getString());
2634 }
2635
2636 public void renderPortlet(
2637 StringBuilder sb, ServletContext servletContext,
2638 HttpServletRequest request, HttpServletResponse response,
2639 Portlet portlet, String queryString)
2640 throws IOException, ServletException {
2641
2642 renderPortlet(
2643 sb, servletContext, request, response, portlet, queryString, null,
2644 null, null);
2645 }
2646
2647 public void renderPortlet(
2648 StringBuilder sb, ServletContext servletContext,
2649 HttpServletRequest request, HttpServletResponse response,
2650 Portlet portlet, String queryString, String columnId,
2651 Integer columnPos, Integer columnCount)
2652 throws IOException, ServletException {
2653
2654 renderPortlet(
2655 sb, servletContext, request, response, portlet, queryString,
2656 columnId, columnPos, columnCount, null);
2657 }
2658
2659 public void renderPortlet(
2660 StringBuilder sb, ServletContext servletContext,
2661 HttpServletRequest request, HttpServletResponse response,
2662 Portlet portlet, String queryString, String columnId,
2663 Integer columnPos, Integer columnCount, String path)
2664 throws IOException, ServletException {
2665
2666 queryString = GetterUtil.getString(queryString);
2667 columnId = GetterUtil.getString(columnId);
2668
2669 if (columnPos == null) {
2670 columnPos = new Integer(0);
2671 }
2672
2673 if (columnCount == null) {
2674 columnCount = new Integer(0);
2675 }
2676
2677 request.setAttribute(WebKeys.RENDER_PORTLET, portlet);
2678 request.setAttribute(WebKeys.RENDER_PORTLET_QUERY_STRING, queryString);
2679 request.setAttribute(WebKeys.RENDER_PORTLET_COLUMN_ID, columnId);
2680 request.setAttribute(WebKeys.RENDER_PORTLET_COLUMN_POS, columnPos);
2681 request.setAttribute(WebKeys.RENDER_PORTLET_COLUMN_COUNT, columnCount);
2682
2683 if (path == null) {
2684 path = "/html/portal/render_portlet.jsp";
2685 }
2686
2687 RequestDispatcher requestDispatcher =
2688 servletContext.getRequestDispatcher(path);
2689
2690 if (sb != null) {
2691 StringServletResponse stringResponse = new StringServletResponse(
2692 response);
2693
2694 requestDispatcher.include(request, stringResponse);
2695
2696 boolean showPortlet = true;
2697
2698 Boolean portletConfiguratorVisibility =
2699 (Boolean)request.getAttribute(
2700 WebKeys.PORTLET_CONFIGURATOR_VISIBILITY);
2701
2702 if (portletConfiguratorVisibility != null) {
2703 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
2704 WebKeys.THEME_DISPLAY);
2705
2706 try {
2707 if (!PortletPermissionUtil.contains(
2708 themeDisplay.getPermissionChecker(),
2709 portlet.getPortletId(), ActionKeys.CONFIGURATION)) {
2710
2711 showPortlet = false;
2712 }
2713 }
2714 catch (Exception e) {
2715 throw new ServletException(e);
2716 }
2717
2718 request.removeAttribute(
2719 WebKeys.PORTLET_CONFIGURATOR_VISIBILITY);
2720 }
2721
2722 if (showPortlet) {
2723 sb.append(stringResponse.getString());
2724 }
2725 }
2726 else {
2727
2728
2730 response.setContentType(ContentTypes.TEXT_HTML_UTF8);
2731
2732 requestDispatcher.include(request, response);
2733 }
2734 }
2735
2736 public void sendError(
2737 Exception e, HttpServletRequest request,
2738 HttpServletResponse response)
2739 throws IOException, ServletException {
2740
2741 sendError(0, e, request, response);
2742 }
2743
2744 public void sendError(
2745 int status, Exception e, HttpServletRequest request,
2746 HttpServletResponse response)
2747 throws IOException, ServletException {
2748
2749 if (status == 0) {
2750 if (e instanceof PrincipalException) {
2751 status = HttpServletResponse.SC_FORBIDDEN;
2752 }
2753 else {
2754 String name = e.getClass().getName();
2755
2756 name = name.substring(name.lastIndexOf(StringPool.PERIOD) + 1);
2757
2758 if (name.startsWith("NoSuch") && name.endsWith("Exception")) {
2759 status = HttpServletResponse.SC_NOT_FOUND;
2760 }
2761 }
2762
2763 if (status == 0) {
2764 status = HttpServletResponse.SC_INTERNAL_SERVER_ERROR;
2765 }
2766 }
2767
2768 HttpSession session = request.getSession();
2769
2770 ServletContext servletContext = session.getServletContext();
2771
2772 String redirect = PATH_MAIN + "/portal/status";
2773
2774 if (e instanceof NoSuchLayoutException &&
2775 Validator.isNotNull(
2776 PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND)) {
2777
2778 response.setStatus(status);
2779
2780 redirect = PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND;
2781
2782 RequestDispatcher requestDispatcher =
2783 servletContext.getRequestDispatcher(redirect);
2784
2785 if (requestDispatcher != null) {
2786 requestDispatcher.forward(request, response);
2787 }
2788 }
2789 else if (PropsValues.LAYOUT_SHOW_HTTP_STATUS) {
2790 response.setStatus(status);
2791
2792 SessionErrors.add(request, e.getClass().getName(), e);
2793
2794 RequestDispatcher requestDispatcher =
2795 servletContext.getRequestDispatcher(redirect);
2796
2797 if (requestDispatcher != null) {
2798 requestDispatcher.forward(request, response);
2799 }
2800 }
2801 else {
2802 if (e != null) {
2803 response.sendError(status, e.getMessage());
2804 }
2805 else {
2806 response.sendError(status);
2807 }
2808 }
2809 }
2810
2811 public void sendError(
2812 Exception e, ActionRequest actionRequest,
2813 ActionResponse actionResponse)
2814 throws IOException {
2815
2816 sendError(0, e, actionRequest, actionResponse);
2817 }
2818
2819 public void sendError(
2820 int status, Exception e, ActionRequest actionRequest,
2821 ActionResponse actionResponse)
2822 throws IOException {
2823
2824 StringBuilder sb = new StringBuilder();
2825
2826 sb.append(_pathMain);
2827 sb.append("/portal/status?status=");
2828 sb.append(status);
2829 sb.append("&exception=");
2830 sb.append(e.getClass().getName());
2831 sb.append("&previousURL=");
2832 sb.append(HttpUtil.encodeURL(PortalUtil.getCurrentURL(actionRequest)));
2833
2834 actionResponse.sendRedirect(sb.toString());
2835 }
2836
2837
2844 public void setPageSubtitle(String subtitle, HttpServletRequest request) {
2845 request.setAttribute(WebKeys.PAGE_SUBTITLE, subtitle);
2846 }
2847
2848
2855 public void setPageTitle(String title, HttpServletRequest request) {
2856 request.setAttribute(WebKeys.PAGE_TITLE, title);
2857 }
2858
2859
2864 public void setPortalPort(HttpServletRequest request) {
2865 if (_portalPort.intValue() == -1) {
2866 synchronized (_portalPort) {
2867 _portalPort = new Integer(request.getServerPort());
2868 }
2869 }
2870 }
2871
2872 public void storePreferences(PortletPreferences preferences)
2873 throws IOException, ValidatorException {
2874
2875 PortletPreferencesWrapper preferencesWrapper =
2876 (PortletPreferencesWrapper)preferences;
2877
2878 PortletPreferencesImpl preferencesImpl =
2879 preferencesWrapper.getPreferencesImpl();
2880
2881 preferencesImpl.store();
2882 }
2883
2884 public String transformCustomSQL(String sql) {
2885 if ((_customSqlClassNames == null) ||
2886 (_customSqlClassNameIds == null)) {
2887
2888 _initCustomSQL();
2889 }
2890
2891 return StringUtil.replace(
2892 sql, _customSqlClassNames, _customSqlClassNameIds);
2893 }
2894
2895 public PortletMode updatePortletMode(
2896 String portletId, User user, Layout layout, PortletMode portletMode,
2897 HttpServletRequest request) {
2898
2899 LayoutTypePortlet layoutType =
2900 (LayoutTypePortlet)layout.getLayoutType();
2901
2902 if (portletMode == null || Validator.isNull(portletMode.toString())) {
2903 if (layoutType.hasModeAboutPortletId(portletId)) {
2904 return LiferayPortletMode.ABOUT;
2905 }
2906 else if (layoutType.hasModeConfigPortletId(portletId)) {
2907 return LiferayPortletMode.CONFIG;
2908 }
2909 else if (layoutType.hasModeEditPortletId(portletId)) {
2910 return PortletMode.EDIT;
2911 }
2912 else if (layoutType.hasModeEditDefaultsPortletId(portletId)) {
2913 return LiferayPortletMode.EDIT_DEFAULTS;
2914 }
2915 else if (layoutType.hasModeEditGuestPortletId(portletId)) {
2916 return LiferayPortletMode.EDIT_GUEST;
2917 }
2918 else if (layoutType.hasModeHelpPortletId(portletId)) {
2919 return PortletMode.HELP;
2920 }
2921 else if (layoutType.hasModePreviewPortletId(portletId)) {
2922 return LiferayPortletMode.PREVIEW;
2923 }
2924 else if (layoutType.hasModePrintPortletId(portletId)) {
2925 return LiferayPortletMode.PRINT;
2926 }
2927 else {
2928 return PortletMode.VIEW;
2929 }
2930 }
2931 else {
2932 boolean updateLayout = false;
2933
2934 if (portletMode.equals(LiferayPortletMode.ABOUT) &&
2935 !layoutType.hasModeAboutPortletId(portletId)) {
2936
2937 layoutType.addModeAboutPortletId(portletId);
2938
2939 updateLayout = true;
2940 }
2941 else if (portletMode.equals(LiferayPortletMode.CONFIG) &&
2942 !layoutType.hasModeConfigPortletId(portletId)) {
2943
2944 layoutType.addModeConfigPortletId(portletId);
2945
2946 updateLayout = true;
2947 }
2948 else if (portletMode.equals(PortletMode.EDIT) &&
2949 !layoutType.hasModeEditPortletId(portletId)) {
2950
2951 layoutType.addModeEditPortletId(portletId);
2952
2953 updateLayout = true;
2954 }
2955 else if (portletMode.equals(LiferayPortletMode.EDIT_DEFAULTS) &&
2956 !layoutType.hasModeEditDefaultsPortletId(portletId)) {
2957
2958 layoutType.addModeEditDefaultsPortletId(portletId);
2959
2960 updateLayout = true;
2961 }
2962 else if (portletMode.equals(LiferayPortletMode.EDIT_GUEST) &&
2963 !layoutType.hasModeEditGuestPortletId(portletId)) {
2964
2965 layoutType.addModeEditGuestPortletId(portletId);
2966
2967 updateLayout = true;
2968 }
2969 else if (portletMode.equals(PortletMode.HELP) &&
2970 !layoutType.hasModeHelpPortletId(portletId)) {
2971
2972 layoutType.addModeHelpPortletId(portletId);
2973
2974 updateLayout = true;
2975 }
2976 else if (portletMode.equals(LiferayPortletMode.PREVIEW) &&
2977 !layoutType.hasModePreviewPortletId(portletId)) {
2978
2979 layoutType.addModePreviewPortletId(portletId);
2980
2981 updateLayout = true;
2982 }
2983 else if (portletMode.equals(LiferayPortletMode.PRINT) &&
2984 !layoutType.hasModePrintPortletId(portletId)) {
2985
2986 layoutType.addModePrintPortletId(portletId);
2987
2988 updateLayout = true;
2989 }
2990 else if (portletMode.equals(PortletMode.VIEW) &&
2991 !layoutType.hasModeViewPortletId(portletId)) {
2992
2993 layoutType.removeModesPortletId(portletId);
2994
2995 updateLayout = true;
2996 }
2997
2998 if (updateLayout) {
2999 LayoutClone layoutClone = LayoutCloneFactory.getInstance();
3000
3001 if (layoutClone != null) {
3002 layoutClone.update(
3003 request, layout.getPlid(), layout.getTypeSettings());
3004 }
3005 }
3006
3007 return portletMode;
3008 }
3009 }
3010
3011 public WindowState updateWindowState(
3012 String portletId, User user, Layout layout, WindowState windowState,
3013 HttpServletRequest request) {
3014
3015 LayoutTypePortlet layoutType =
3016 (LayoutTypePortlet)layout.getLayoutType();
3017
3018 if ((windowState == null) ||
3019 (Validator.isNull(windowState.toString()))) {
3020
3021 if (layoutType.hasStateMaxPortletId(portletId)) {
3022 return WindowState.MAXIMIZED;
3023 }
3024 else if (layoutType.hasStateMinPortletId(portletId)) {
3025 return WindowState.MINIMIZED;
3026 }
3027 else {
3028 return WindowState.NORMAL;
3029 }
3030 }
3031 else {
3032 boolean updateLayout = false;
3033
3034 if (windowState.equals(WindowState.MAXIMIZED) &&
3035 !layoutType.hasStateMaxPortletId(portletId)) {
3036
3037 layoutType.addStateMaxPortletId(portletId);
3038
3039 updateLayout = false;
3040 }
3041 else if (windowState.equals(WindowState.MINIMIZED) &&
3042 !layoutType.hasStateMinPortletId(portletId)) {
3043
3044 layoutType.addStateMinPortletId(portletId);
3045
3046 updateLayout = true;
3047 }
3048 else if (windowState.equals(WindowState.NORMAL) &&
3049 !layoutType.hasStateNormalPortletId(portletId)) {
3050
3051 layoutType.removeStatesPortletId(portletId);
3052
3053 updateLayout = true;
3054 }
3055
3056 if (updateLayout) {
3057 LayoutClone layoutClone = LayoutCloneFactory.getInstance();
3058
3059 if (layoutClone != null) {
3060 layoutClone.update(
3061 request, layout.getPlid(), layout.getTypeSettings());
3062 }
3063 }
3064
3065 return windowState;
3066 }
3067 }
3068
3069 protected long getDoAsUserId(
3070 HttpServletRequest request, String doAsUserIdString,
3071 boolean alwaysAllowDoAsUser)
3072 throws Exception {
3073
3074 if (Validator.isNull(doAsUserIdString)) {
3075 return 0;
3076 }
3077
3078 long doAsUserId = 0;
3079
3080 try {
3081 Company company = getCompany(request);
3082
3083 doAsUserId = GetterUtil.getLong(
3084 Encryptor.decrypt(company.getKeyObj(), doAsUserIdString));
3085 }
3086 catch (Exception e) {
3087 if (_log.isWarnEnabled()) {
3088 _log.warn(
3089 "Unable to impersonate " + doAsUserIdString +
3090 " because the string cannot be decrypted",
3091 e);
3092 }
3093
3094 return 0;
3095 }
3096
3097 if (_log.isDebugEnabled()) {
3098 if (alwaysAllowDoAsUser) {
3099 _log.debug(
3100 "doAsUserId path or Struts action is always allowed");
3101 }
3102 else {
3103 _log.debug(
3104 "doAsUserId path is Struts action not always allowed");
3105 }
3106 }
3107
3108 if (alwaysAllowDoAsUser) {
3109 request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
3110
3111 return doAsUserId;
3112 }
3113
3114 HttpSession session = request.getSession();
3115
3116 Long realUserIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
3117
3118 if (realUserIdObj == null) {
3119 return 0;
3120 }
3121
3122 User doAsUser = UserLocalServiceUtil.getUserById(doAsUserId);
3123
3124 long[] organizationIds = doAsUser.getOrganizationIds();
3125
3126 User realUser = UserLocalServiceUtil.getUserById(
3127 realUserIdObj.longValue());
3128 boolean checkGuest = true;
3129
3130 PermissionChecker permissionChecker =
3131 PermissionCheckerFactoryUtil.create(realUser, checkGuest);
3132
3133 if (doAsUser.isDefaultUser() ||
3134 UserPermissionUtil.contains(
3135 permissionChecker, doAsUserId, organizationIds,
3136 ActionKeys.IMPERSONATE)) {
3137
3138 request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
3139
3140 return doAsUserId;
3141 }
3142 else {
3143 _log.error(
3144 "User " + realUserIdObj + " does not have the permission " +
3145 "to impersonate " + doAsUserId);
3146
3147 return 0;
3148 }
3149 }
3150
3151 private String _getCurrentURL(HttpServletRequest request) {
3152 StringBuilder sb = new StringBuilder();
3153
3154 StringBuffer requestURL = request.getRequestURL();
3155
3156 if (requestURL != null) {
3157 sb.append(requestURL.toString());
3158 }
3159
3160 String queryString = request.getQueryString();
3161
3162 if (Validator.isNull(queryString)) {
3163 return sb.toString();
3164 }
3165
3166 String portletId = request.getParameter("p_p_id");
3167
3168 String redirectParam = "redirect";
3169
3170 if (Validator.isNotNull(portletId)) {
3171 redirectParam = getPortletNamespace(portletId) + redirectParam;
3172 }
3173
3174 Map<String, String[]> parameterMap = HttpUtil.parameterMapFromString(
3175 queryString);
3176
3177 String[] redirectValues = parameterMap.get(redirectParam);
3178
3179 if ((redirectValues != null) && (redirectValues.length > 0)) {
3180
3181
3185 String redirect = HttpUtil.decodeURL(
3186 GetterUtil.getString(redirectValues[0]));
3187
3188 int pos = redirect.indexOf(StringPool.QUESTION);
3189
3190 if (pos != -1) {
3191 String subqueryString = redirect.substring(
3192 pos + 1, redirect.length());
3193
3194 Map<String, String[]> subparameterMap =
3195 HttpUtil.parameterMapFromString(subqueryString);
3196
3197 String[] subredirectValues = subparameterMap.get(redirectParam);
3198
3199 if ((subredirectValues != null) &&
3200 (subredirectValues.length > 0)) {
3201
3202 String subredirect = HttpUtil.decodeURL(
3203 GetterUtil.getString(subredirectValues[0]));
3204
3205 parameterMap.put(redirectParam, new String[] {subredirect});
3206
3207 queryString = HttpUtil.parameterMapToString(
3208 parameterMap, false);
3209 }
3210 }
3211 }
3212
3213 sb.append(StringPool.QUESTION);
3214 sb.append(queryString);
3215
3216 return sb.toString();
3217 }
3218
3219 private long _getPlidFromPortletId(
3220 long groupId, boolean privateLayout, String portletId) {
3221
3222 long plid = LayoutConstants.DEFAULT_PLID;
3223
3224 try {
3225 List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
3226 groupId, privateLayout, LayoutConstants.TYPE_PORTLET);
3227
3228 for (Layout layout : layouts) {
3229 LayoutTypePortlet layoutTypePortlet =
3230 (LayoutTypePortlet)layout.getLayoutType();
3231
3232 if (layoutTypePortlet.hasPortletId(portletId)) {
3233 if (getScopeGroupId(layout, portletId) == groupId) {
3234 plid = layout.getPlid();
3235
3236 break;
3237 }
3238 }
3239 }
3240 }
3241 catch (SystemException se) {
3242 if (_log.isWarnEnabled()) {
3243 _log.warn(se.getMessage());
3244 }
3245 }
3246
3247 return plid;
3248 }
3249
3250 private String _getPortletParam(HttpServletRequest request, String name) {
3251 String value = null;
3252
3253 int valueCount = 0;
3254
3255 Enumeration<String> enu = request.getParameterNames();
3256
3257 while (enu.hasMoreElements()) {
3258 String curName = enu.nextElement();
3259
3260 int pos = curName.indexOf(StringPool.UNDERLINE + name);
3261
3262 if (pos != -1) {
3263 valueCount++;
3264
3265
3267 if (valueCount > 1) {
3268 return StringPool.BLANK;
3269 }
3270
3271 String curValue = ParamUtil.getString(request, curName);
3272
3273 if (Validator.isNotNull(curValue)) {
3274
3275
3277 String portletId1 = curName.substring(1, pos);
3278 String portletId2 = ParamUtil.getString(request, "p_p_id");
3279
3280 if (portletId1.equals(portletId2)) {
3281 value = curValue;
3282 }
3283 }
3284 }
3285 }
3286
3287 if (value == null) {
3288 value = StringPool.BLANK;
3289 }
3290
3291 return value;
3292 }
3293
3294 private void _initCustomSQL() {
3295 _customSqlClassNames = new String[] {
3296 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ORGANIZATION$]",
3297 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USER$]",
3298 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USERGROUP$]",
3299 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BLOGS.MODEL.BLOGSENTRY$]",
3300 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BOOKMARKS.MODEL." +
3301 "BOOKMARKSENTRY$]",
3302 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.DOCUMENTLIBRARY.MODEL." +
3303 "DLFILEENTRY$]",
3304 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.IMAGEGALLERY.MODEL.IGIMAGE$]",
3305 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.MESSAGEBOARDS.MODEL." +
3306 "MBMESSAGE$]",
3307 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.WIKI.MODEL.WIKIPAGE$]",
3308 "[$FALSE$]",
3309 "[$TRUE$]"
3310 };
3311
3312 DBUtil dbUtil = DBUtil.getInstance();
3313
3314 _customSqlClassNameIds = new String[] {
3315 String.valueOf(PortalUtil.getClassNameId(Organization.class)),
3316 String.valueOf(PortalUtil.getClassNameId(User.class)),
3317 String.valueOf(PortalUtil.getClassNameId(UserGroup.class)),
3318 String.valueOf(PortalUtil.getClassNameId(BlogsEntry.class)),
3319 String.valueOf(PortalUtil.getClassNameId(BookmarksEntry.class)),
3320 String.valueOf(PortalUtil.getClassNameId(DLFileEntry.class)),
3321 String.valueOf(PortalUtil.getClassNameId(IGImage.class)),
3322 String.valueOf(PortalUtil.getClassNameId(MBMessage.class)),
3323 String.valueOf(PortalUtil.getClassNameId(WikiPage.class)),
3324 dbUtil.getTemplateFalse(),
3325 dbUtil.getTemplateTrue()
3326 };
3327 }
3328
3329 private static final String _JSESSIONID = ";jsessionid=";
3330
3331 private static final String _LOCALHOST = "localhost";
3332
3333 private static final String _PRIVATE_GROUP_SERVLET_MAPPING =
3334 PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_GROUP_SERVLET_MAPPING;
3335
3336 private static final String _PRIVATE_USER_SERVLET_MAPPING =
3337 PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_USER_SERVLET_MAPPING;
3338
3339 private static final String _PUBLIC_GROUP_SERVLET_MAPPING =
3340 PropsValues.LAYOUT_FRIENDLY_URL_PUBLIC_SERVLET_MAPPING;
3341
3342 private static Log _log = LogFactoryUtil.getLog(PortalImpl.class);
3343
3344 private String _computerAddress;
3345 private String _computerName;
3346 private String _portalLibDir;
3347 private String _portalWebDir;
3348 private String _cdnHost;
3349 private String _pathContext;
3350 private String _pathFriendlyURLPrivateGroup;
3351 private String _pathFriendlyURLPrivateUser;
3352 private String _pathFriendlyURLPublic;
3353 private String _pathImage;
3354 private String _pathMain;
3355 private Integer _portalPort = new Integer(-1);
3356 private String[] _allSystemCommunityRoles;
3357 private String[] _allSystemGroups;
3358 private String[] _allSystemOrganizationRoles;
3359 private String[] _allSystemRoles;
3360 private String[] _sortedSystemCommunityRoles;
3361 private String[] _sortedSystemGroups;
3362 private String[] _sortedSystemOrganizationRoles;
3363 private String[] _sortedSystemRoles;
3364 private Set<String> _reservedParams;
3365 private String[] _customSqlClassNames = null;
3366 private String[] _customSqlClassNameIds = null;
3367 private Map<String, Long> _plidToPortletIdCache =
3368 new ConcurrentHashMap<String, Long>();
3369
3370}