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