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