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