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