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