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