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