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