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.NoSuchUserException;
021 import com.liferay.portal.cluster.ClusterInvokeThreadLocal;
022 import com.liferay.portal.kernel.bean.BeanPropertiesUtil;
023 import com.liferay.portal.kernel.cluster.ClusterExecutorUtil;
024 import com.liferay.portal.kernel.cluster.ClusterRequest;
025 import com.liferay.portal.kernel.dao.db.DB;
026 import com.liferay.portal.kernel.dao.db.DBFactoryUtil;
027 import com.liferay.portal.kernel.exception.PortalException;
028 import com.liferay.portal.kernel.exception.SystemException;
029 import com.liferay.portal.kernel.language.LanguageUtil;
030 import com.liferay.portal.kernel.log.Log;
031 import com.liferay.portal.kernel.log.LogFactoryUtil;
032 import com.liferay.portal.kernel.portlet.FriendlyURLMapper;
033 import com.liferay.portal.kernel.portlet.FriendlyURLMapperThreadLocal;
034 import com.liferay.portal.kernel.portlet.LiferayPortletMode;
035 import com.liferay.portal.kernel.portlet.LiferayPortletRequest;
036 import com.liferay.portal.kernel.portlet.LiferayPortletResponse;
037 import com.liferay.portal.kernel.portlet.LiferayWindowState;
038 import com.liferay.portal.kernel.portlet.PortletBag;
039 import com.liferay.portal.kernel.portlet.PortletBagPool;
040 import com.liferay.portal.kernel.servlet.BrowserSnifferUtil;
041 import com.liferay.portal.kernel.servlet.DynamicServletRequest;
042 import com.liferay.portal.kernel.servlet.HttpHeaders;
043 import com.liferay.portal.kernel.servlet.HttpMethods;
044 import com.liferay.portal.kernel.servlet.PersistentHttpServletRequestWrapper;
045 import com.liferay.portal.kernel.servlet.PortalSessionThreadLocal;
046 import com.liferay.portal.kernel.servlet.ServletContextUtil;
047 import com.liferay.portal.kernel.servlet.SessionErrors;
048 import com.liferay.portal.kernel.servlet.taglib.ui.BreadcrumbEntry;
049 import com.liferay.portal.kernel.upload.UploadPortletRequest;
050 import com.liferay.portal.kernel.upload.UploadServletRequest;
051 import com.liferay.portal.kernel.util.ArrayUtil;
052 import com.liferay.portal.kernel.util.Base64;
053 import com.liferay.portal.kernel.util.CalendarFactoryUtil;
054 import com.liferay.portal.kernel.util.CharPool;
055 import com.liferay.portal.kernel.util.ContentTypes;
056 import com.liferay.portal.kernel.util.ContextPathUtil;
057 import com.liferay.portal.kernel.util.DeterminateKeyGenerator;
058 import com.liferay.portal.kernel.util.GetterUtil;
059 import com.liferay.portal.kernel.util.HtmlUtil;
060 import com.liferay.portal.kernel.util.Http;
061 import com.liferay.portal.kernel.util.HttpUtil;
062 import com.liferay.portal.kernel.util.InheritableMap;
063 import com.liferay.portal.kernel.util.JavaConstants;
064 import com.liferay.portal.kernel.util.ListMergeable;
065 import com.liferay.portal.kernel.util.ListUtil;
066 import com.liferay.portal.kernel.util.LocaleUtil;
067 import com.liferay.portal.kernel.util.MethodHandler;
068 import com.liferay.portal.kernel.util.MethodKey;
069 import com.liferay.portal.kernel.util.ParamUtil;
070 import com.liferay.portal.kernel.util.PropsKeys;
071 import com.liferay.portal.kernel.util.ReleaseInfo;
072 import com.liferay.portal.kernel.util.ResourceBundleUtil;
073 import com.liferay.portal.kernel.util.SetUtil;
074 import com.liferay.portal.kernel.util.StringBundler;
075 import com.liferay.portal.kernel.util.StringComparator;
076 import com.liferay.portal.kernel.util.StringPool;
077 import com.liferay.portal.kernel.util.StringUtil;
078 import com.liferay.portal.kernel.util.Time;
079 import com.liferay.portal.kernel.util.UnicodeProperties;
080 import com.liferay.portal.kernel.util.Validator;
081 import com.liferay.portal.kernel.xml.QName;
082 import com.liferay.portal.model.AuditedModel;
083 import com.liferay.portal.model.BaseModel;
084 import com.liferay.portal.model.ClassName;
085 import com.liferay.portal.model.ColorScheme;
086 import com.liferay.portal.model.Company;
087 import com.liferay.portal.model.Group;
088 import com.liferay.portal.model.GroupConstants;
089 import com.liferay.portal.model.Layout;
090 import com.liferay.portal.model.LayoutConstants;
091 import com.liferay.portal.model.LayoutSet;
092 import com.liferay.portal.model.LayoutType;
093 import com.liferay.portal.model.LayoutTypePortlet;
094 import com.liferay.portal.model.LayoutTypePortletConstants;
095 import com.liferay.portal.model.Organization;
096 import com.liferay.portal.model.Portlet;
097 import com.liferay.portal.model.PortletConstants;
098 import com.liferay.portal.model.PublicRenderParameter;
099 import com.liferay.portal.model.ResourceConstants;
100 import com.liferay.portal.model.ResourcePermission;
101 import com.liferay.portal.model.Role;
102 import com.liferay.portal.model.RoleConstants;
103 import com.liferay.portal.model.Theme;
104 import com.liferay.portal.model.Ticket;
105 import com.liferay.portal.model.TicketConstants;
106 import com.liferay.portal.model.User;
107 import com.liferay.portal.model.UserGroup;
108 import com.liferay.portal.model.VirtualLayoutConstants;
109 import com.liferay.portal.model.impl.LayoutTypePortletImpl;
110 import com.liferay.portal.model.impl.VirtualLayout;
111 import com.liferay.portal.plugin.PluginPackageUtil;
112 import com.liferay.portal.security.auth.AuthException;
113 import com.liferay.portal.security.auth.AuthTokenUtil;
114 import com.liferay.portal.security.auth.CompanyThreadLocal;
115 import com.liferay.portal.security.auth.PrincipalException;
116 import com.liferay.portal.security.permission.ActionKeys;
117 import com.liferay.portal.security.permission.PermissionChecker;
118 import com.liferay.portal.security.permission.PermissionCheckerFactoryUtil;
119 import com.liferay.portal.security.permission.ResourceActionsUtil;
120 import com.liferay.portal.service.ClassNameLocalServiceUtil;
121 import com.liferay.portal.service.CompanyLocalServiceUtil;
122 import com.liferay.portal.service.GroupLocalServiceUtil;
123 import com.liferay.portal.service.GroupServiceUtil;
124 import com.liferay.portal.service.LayoutLocalServiceUtil;
125 import com.liferay.portal.service.LayoutSetLocalServiceUtil;
126 import com.liferay.portal.service.PortletLocalServiceUtil;
127 import com.liferay.portal.service.ResourceLocalServiceUtil;
128 import com.liferay.portal.service.ResourcePermissionLocalServiceUtil;
129 import com.liferay.portal.service.TicketLocalServiceUtil;
130 import com.liferay.portal.service.UserLocalServiceUtil;
131 import com.liferay.portal.service.UserServiceUtil;
132 import com.liferay.portal.service.permission.GroupPermissionUtil;
133 import com.liferay.portal.service.permission.LayoutPermissionUtil;
134 import com.liferay.portal.service.permission.LayoutPrototypePermissionUtil;
135 import com.liferay.portal.service.permission.LayoutSetPrototypePermissionUtil;
136 import com.liferay.portal.service.permission.OrganizationPermissionUtil;
137 import com.liferay.portal.service.permission.PortletPermissionUtil;
138 import com.liferay.portal.service.permission.UserPermissionUtil;
139 import com.liferay.portal.servlet.filters.i18n.I18nFilter;
140 import com.liferay.portal.servlet.filters.secure.NonceUtil;
141 import com.liferay.portal.struts.StrutsUtil;
142 import com.liferay.portal.theme.PortletDisplay;
143 import com.liferay.portal.theme.ThemeDisplay;
144 import com.liferay.portal.upload.UploadPortletRequestImpl;
145 import com.liferay.portal.upload.UploadServletRequestImpl;
146 import com.liferay.portal.util.comparator.PortletControlPanelWeightComparator;
147 import com.liferay.portal.webserver.WebServerServlet;
148 import com.liferay.portlet.ActionResponseImpl;
149 import com.liferay.portlet.ControlPanelEntry;
150 import com.liferay.portlet.DefaultControlPanelEntryFactory;
151 import com.liferay.portlet.PortletConfigFactoryUtil;
152 import com.liferay.portlet.PortletConfigImpl;
153 import com.liferay.portlet.PortletPreferencesFactoryUtil;
154 import com.liferay.portlet.PortletPreferencesImpl;
155 import com.liferay.portlet.PortletPreferencesWrapper;
156 import com.liferay.portlet.PortletQNameUtil;
157 import com.liferay.portlet.PortletRequestImpl;
158 import com.liferay.portlet.PortletResponseImpl;
159 import com.liferay.portlet.PortletURLFactoryUtil;
160 import com.liferay.portlet.PortletURLImpl;
161 import com.liferay.portlet.RenderRequestImpl;
162 import com.liferay.portlet.RenderResponseImpl;
163 import com.liferay.portlet.StateAwareResponseImpl;
164 import com.liferay.portlet.UserAttributes;
165 import com.liferay.portlet.admin.util.OmniadminUtil;
166 import com.liferay.portlet.asset.model.AssetTag;
167 import com.liferay.portlet.asset.service.AssetTagLocalServiceUtil;
168 import com.liferay.portlet.blogs.model.BlogsEntry;
169 import com.liferay.portlet.bookmarks.model.BookmarksEntry;
170 import com.liferay.portlet.calendar.model.CalEvent;
171 import com.liferay.portlet.documentlibrary.model.DLFileEntry;
172 import com.liferay.portlet.expando.ValueDataException;
173 import com.liferay.portlet.expando.model.ExpandoBridge;
174 import com.liferay.portlet.expando.model.ExpandoColumnConstants;
175 import com.liferay.portlet.journal.NoSuchFeedException;
176 import com.liferay.portlet.journal.asset.JournalArticleAssetRendererFactory;
177 import com.liferay.portlet.journal.model.JournalArticle;
178 import com.liferay.portlet.journal.model.JournalArticleConstants;
179 import com.liferay.portlet.journal.service.JournalArticleLocalServiceUtil;
180 import com.liferay.portlet.login.util.LoginUtil;
181 import com.liferay.portlet.messageboards.model.MBMessage;
182 import com.liferay.portlet.messageboards.model.MBThread;
183 import com.liferay.portlet.social.model.SocialRelationConstants;
184 import com.liferay.portlet.social.util.FacebookUtil;
185 import com.liferay.portlet.wiki.model.WikiPage;
186 import com.liferay.util.Encryptor;
187 import com.liferay.util.JS;
188 import com.liferay.util.PwdGenerator;
189
190 import java.io.IOException;
191 import java.io.Serializable;
192
193 import java.lang.reflect.Method;
194
195 import java.net.InetAddress;
196 import java.net.UnknownHostException;
197
198 import java.util.ArrayList;
199 import java.util.Arrays;
200 import java.util.Calendar;
201 import java.util.Collection;
202 import java.util.Collections;
203 import java.util.Date;
204 import java.util.Enumeration;
205 import java.util.HashMap;
206 import java.util.HashSet;
207 import java.util.Iterator;
208 import java.util.List;
209 import java.util.Locale;
210 import java.util.Map;
211 import java.util.Properties;
212 import java.util.ResourceBundle;
213 import java.util.Set;
214 import java.util.TimeZone;
215 import java.util.TreeSet;
216 import java.util.concurrent.ConcurrentHashMap;
217 import java.util.concurrent.atomic.AtomicInteger;
218 import java.util.regex.Matcher;
219 import java.util.regex.Pattern;
220
221 import javax.portlet.ActionRequest;
222 import javax.portlet.ActionResponse;
223 import javax.portlet.PortletConfig;
224 import javax.portlet.PortletMode;
225 import javax.portlet.PortletPreferences;
226 import javax.portlet.PortletRequest;
227 import javax.portlet.PortletResponse;
228 import javax.portlet.PortletURL;
229 import javax.portlet.PreferencesValidator;
230 import javax.portlet.RenderRequest;
231 import javax.portlet.RenderResponse;
232 import javax.portlet.ValidatorException;
233 import javax.portlet.WindowState;
234
235 import javax.servlet.RequestDispatcher;
236 import javax.servlet.ServletContext;
237 import javax.servlet.ServletException;
238 import javax.servlet.http.HttpServletRequest;
239 import javax.servlet.http.HttpServletRequestWrapper;
240 import javax.servlet.http.HttpServletResponse;
241 import javax.servlet.http.HttpSession;
242 import javax.servlet.jsp.PageContext;
243
244 import org.apache.struts.Globals;
245
246
256 public class PortalImpl implements Portal {
257
258 public PortalImpl() {
259
260
261
262 _computerName = System.getProperty("env.COMPUTERNAME");
263
264 if (Validator.isNull(_computerName)) {
265 _computerName = System.getProperty("env.HOST");
266 }
267
268 if (Validator.isNull(_computerName)) {
269 _computerName = System.getProperty("env.HOSTNAME");
270 }
271
272 if (Validator.isNull(_computerName)) {
273 try {
274 _computerName = InetAddress.getLocalHost().getHostName();
275 }
276 catch (UnknownHostException uhe) {
277 }
278 }
279
280 try {
281 _computerAddress = InetAddress.getByName(
282 _computerName).getHostAddress();
283 }
284 catch (UnknownHostException uhe) {
285 }
286
287 if (Validator.isNull(_computerAddress)) {
288 try {
289 _computerAddress = InetAddress.getLocalHost().getHostAddress();
290 }
291 catch (UnknownHostException uhe) {
292 }
293 }
294
295
296
297 _pathProxy = PropsValues.PORTAL_PROXY_PATH;
298
299 _pathContext = ContextPathUtil.getContextPath(PropsValues.PORTAL_CTX);
300 _pathContext = _pathProxy.concat(_pathContext);
301
302 _pathFriendlyURLPrivateGroup =
303 _pathContext + _PRIVATE_GROUP_SERVLET_MAPPING;
304 _pathFriendlyURLPrivateUser =
305 _pathContext + _PRIVATE_USER_SERVLET_MAPPING;
306 _pathFriendlyURLPublic = _pathContext + _PUBLIC_GROUP_SERVLET_MAPPING;
307 _pathImage = _pathContext + PATH_IMAGE;
308 _pathMain = _pathContext + PATH_MAIN;
309
310
311
312 String[] customSystemGroups = PropsUtil.getArray(
313 PropsKeys.SYSTEM_GROUPS);
314
315 if ((customSystemGroups == null) || (customSystemGroups.length == 0)) {
316 _allSystemGroups = GroupConstants.SYSTEM_GROUPS;
317 }
318 else {
319 _allSystemGroups = ArrayUtil.append(
320 GroupConstants.SYSTEM_GROUPS, customSystemGroups);
321 }
322
323 _sortedSystemGroups = new String[_allSystemGroups.length];
324
325 System.arraycopy(
326 _allSystemGroups, 0, _sortedSystemGroups, 0,
327 _allSystemGroups.length);
328
329 Arrays.sort(_sortedSystemGroups, new StringComparator());
330
331
332
333 String[] customSystemRoles = PropsUtil.getArray(PropsKeys.SYSTEM_ROLES);
334
335 if ((customSystemRoles == null) || (customSystemRoles.length == 0)) {
336 _allSystemRoles = RoleConstants.SYSTEM_ROLES;
337 }
338 else {
339 _allSystemRoles = ArrayUtil.append(
340 RoleConstants.SYSTEM_ROLES, customSystemRoles);
341 }
342
343 _sortedSystemRoles = new String[_allSystemRoles.length];
344
345 System.arraycopy(
346 _allSystemRoles, 0, _sortedSystemRoles, 0, _allSystemRoles.length);
347
348 Arrays.sort(_sortedSystemRoles, new StringComparator());
349
350
351
352 String[] customSystemOrganizationRoles = PropsUtil.getArray(
353 PropsKeys.SYSTEM_ORGANIZATION_ROLES);
354
355 if ((customSystemOrganizationRoles == null) ||
356 (customSystemOrganizationRoles.length == 0)) {
357
358 _allSystemOrganizationRoles =
359 RoleConstants.SYSTEM_ORGANIZATION_ROLES;
360 }
361 else {
362 _allSystemOrganizationRoles = ArrayUtil.append(
363 RoleConstants.SYSTEM_ORGANIZATION_ROLES,
364 customSystemOrganizationRoles);
365 }
366
367 _sortedSystemOrganizationRoles =
368 new String[_allSystemOrganizationRoles.length];
369
370 System.arraycopy(
371 _allSystemOrganizationRoles, 0, _sortedSystemOrganizationRoles, 0,
372 _allSystemOrganizationRoles.length);
373
374 Arrays.sort(_sortedSystemOrganizationRoles, new StringComparator());
375
376
377
378 String[] customSystemSiteRoles = PropsUtil.getArray(
379 PropsKeys.SYSTEM_SITE_ROLES);
380
381 if ((customSystemSiteRoles == null) ||
382 (customSystemSiteRoles.length == 0)) {
383
384 _allSystemSiteRoles = RoleConstants.SYSTEM_SITE_ROLES;
385 }
386 else {
387 _allSystemSiteRoles = ArrayUtil.append(
388 RoleConstants.SYSTEM_SITE_ROLES, customSystemSiteRoles);
389 }
390
391 _sortedSystemSiteRoles = new String[_allSystemSiteRoles.length];
392
393 System.arraycopy(
394 _allSystemSiteRoles, 0, _sortedSystemSiteRoles, 0,
395 _allSystemSiteRoles.length);
396
397 Arrays.sort(_sortedSystemSiteRoles, new StringComparator());
398
399
400
401 _authTokenIgnoreActions = SetUtil.fromArray(
402 PropsValues.AUTH_TOKEN_IGNORE_ACTIONS);
403 _authTokenIgnorePortlets = SetUtil.fromArray(
404 PropsValues.AUTH_TOKEN_IGNORE_PORTLETS);
405
406
407
408 resetPortletAddDefaultResourceCheckWhitelist();
409 resetPortletAddDefaultResourceCheckWhitelistActions();
410
411
412
413 _reservedParams = new HashSet<String>();
414
415
416
417 _reservedParams.add("p_auth");
418 _reservedParams.add("p_auth_secret");
419
420
421
422 _reservedParams.add("p_l_id");
423 _reservedParams.add("p_l_reset");
424
425
426
427 _reservedParams.add("p_p_auth");
428 _reservedParams.add("p_p_id");
429 _reservedParams.add("p_p_i_id");
430 _reservedParams.add("p_p_lifecycle");
431 _reservedParams.add("p_p_url_type");
432 _reservedParams.add("p_p_state");
433 _reservedParams.add("p_p_state_rcv");
434 _reservedParams.add("p_p_mode");
435 _reservedParams.add("p_p_resource_id");
436 _reservedParams.add("p_p_cacheability");
437 _reservedParams.add("p_p_width");
438 _reservedParams.add("p_p_col_id");
439 _reservedParams.add("p_p_col_pos");
440 _reservedParams.add("p_p_col_count");
441 _reservedParams.add("p_p_static");
442 _reservedParams.add("p_p_isolated");
443
444
445
446 _reservedParams.add("p_t_lifecycle");
447
448
449
450 _reservedParams.add("p_v_l_s_g_id");
451
452
453
454 _reservedParams.add("p_f_id");
455
456
457
458 _reservedParams.add("p_j_a_id");
459
460
461
462 _reservedParams.add("saveLastPath");
463 _reservedParams.add("scroll");
464 }
465
466 public void addPageDescription(
467 String description, HttpServletRequest request) {
468
469 ListMergeable<String> descriptionListMergeable =
470 (ListMergeable<String>)request.getAttribute(
471 WebKeys.PAGE_DESCRIPTION);
472
473 if (descriptionListMergeable == null) {
474 descriptionListMergeable = new ListMergeable<String>();
475
476 request.setAttribute(
477 WebKeys.PAGE_DESCRIPTION, descriptionListMergeable);
478 }
479
480 descriptionListMergeable.add(description);
481
482 }
483
484 public void addPageKeywords(String keywords, HttpServletRequest request) {
485 ListMergeable<String> keywordsListMergeable =
486 (ListMergeable<String>)request.getAttribute(WebKeys.PAGE_KEYWORDS);
487
488 if (keywordsListMergeable == null) {
489 keywordsListMergeable = new ListMergeable<String>();
490
491 request.setAttribute(WebKeys.PAGE_KEYWORDS, keywordsListMergeable);
492 }
493
494 String[] keywordsArray = StringUtil.split(keywords);
495
496 for (String keyword : keywordsArray) {
497 if (!keywordsListMergeable.contains(keyword.toLowerCase())) {
498 keywordsListMergeable.add(keyword.toLowerCase());
499 }
500 }
501 }
502
503 public void addPageSubtitle(String subtitle, HttpServletRequest request) {
504 ListMergeable<String> subtitleListMergeable =
505 (ListMergeable<String>)request.getAttribute(WebKeys.PAGE_SUBTITLE);
506
507 if (subtitleListMergeable == null) {
508 subtitleListMergeable = new ListMergeable<String>();
509
510 request.setAttribute(WebKeys.PAGE_SUBTITLE, subtitleListMergeable);
511 }
512
513 subtitleListMergeable.add(subtitle);
514 }
515
516 public void addPageTitle(String title, HttpServletRequest request) {
517 ListMergeable<String> titleListMergeable =
518 (ListMergeable<String>)request.getAttribute(WebKeys.PAGE_TITLE);
519
520 if (titleListMergeable != null) {
521 titleListMergeable = new ListMergeable<String>();
522
523 request.setAttribute(WebKeys.PAGE_TITLE, titleListMergeable);
524 }
525
526 titleListMergeable.add(title);
527 }
528
529 public void addPortalPortEventListener(
530 PortalPortEventListener portalPortEventListener) {
531
532 if (!_portalPortEventListeners.contains(portalPortEventListener)) {
533 _portalPortEventListeners.add(portalPortEventListener);
534 }
535 }
536
537 public void addPortletBreadcrumbEntry(
538 HttpServletRequest request, String title, String url) {
539
540 addPortletBreadcrumbEntry(request, title, url, null);
541 }
542
543 public void addPortletBreadcrumbEntry(
544 HttpServletRequest request, String title, String url,
545 Map<String, Object> data) {
546
547 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
548 WebKeys.THEME_DISPLAY);
549
550 PortletDisplay portletDisplay = themeDisplay.getPortletDisplay();
551
552 String name = WebKeys.PORTLET_BREADCRUMBS;
553
554 if (Validator.isNotNull(portletDisplay.getId()) &&
555 !portletDisplay.isFocused()) {
556
557 name += StringPool.UNDERLINE + portletDisplay.getId();
558 }
559
560 List<BreadcrumbEntry> breadcrumbEntries =
561 (List<BreadcrumbEntry>)request.getAttribute(name);
562
563 if (breadcrumbEntries == null) {
564 breadcrumbEntries = new ArrayList<BreadcrumbEntry>();
565
566 request.setAttribute(name, breadcrumbEntries);
567 }
568
569 BreadcrumbEntry breadcrumbEntry = new BreadcrumbEntry();
570
571 breadcrumbEntry.setData(data);
572 breadcrumbEntry.setTitle(title);
573 breadcrumbEntry.setURL(url);
574
575 breadcrumbEntries.add(breadcrumbEntry);
576 }
577
578 public void addPortletDefaultResource(
579 HttpServletRequest request, Portlet portlet)
580 throws PortalException, SystemException {
581
582 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
583 WebKeys.THEME_DISPLAY);
584
585 Layout layout = themeDisplay.getLayout();
586
587 long groupId = 0;
588
589 if (layout.isTypeControlPanel()) {
590 groupId = themeDisplay.getScopeGroupId();
591 }
592 else {
593 groupId = getScopeGroupId(layout, portlet.getPortletId());
594 }
595
596 addDefaultResource(
597 themeDisplay.getCompanyId(), groupId, layout, portlet, true);
598 addDefaultResource(
599 themeDisplay.getCompanyId(), groupId, layout, portlet, false);
600 }
601
602 public void addPortletDefaultResource(
603 long companyId, Layout layout, Portlet portlet)
604 throws PortalException, SystemException {
605
606 addDefaultResource(companyId, layout, portlet, true);
607 addDefaultResource(companyId, layout, portlet, false);
608 }
609
610 public String addPreservedParameters(
611 ThemeDisplay themeDisplay, Layout layout, String url,
612 boolean doAsUser) {
613
614 if (doAsUser) {
615 if (Validator.isNotNull(themeDisplay.getDoAsUserId())) {
616 url = HttpUtil.addParameter(
617 url, "doAsUserId", themeDisplay.getDoAsUserId());
618 }
619
620 if (Validator.isNotNull(themeDisplay.getDoAsUserLanguageId())) {
621 url = HttpUtil.addParameter(
622 url, "doAsUserLanguageId",
623 themeDisplay.getDoAsUserLanguageId());
624 }
625 }
626
627 if (layout.isTypeControlPanel()) {
628 if (themeDisplay.getDoAsGroupId() > 0) {
629 url = HttpUtil.addParameter(
630 url, "doAsGroupId", themeDisplay.getDoAsGroupId());
631 }
632
633 if (themeDisplay.getRefererPlid() != LayoutConstants.DEFAULT_PLID) {
634 url = HttpUtil.addParameter(
635 url, "refererPlid", themeDisplay.getRefererPlid());
636 }
637
638 if (Validator.isNotNull(themeDisplay.getControlPanelCategory())) {
639 url = HttpUtil.addParameter(
640 url, "controlPanelCategory",
641 themeDisplay.getControlPanelCategory());
642 }
643 }
644
645 return url;
646 }
647
648 public String addPreservedParameters(
649 ThemeDisplay themeDisplay, String url) {
650
651 return addPreservedParameters(
652 themeDisplay, themeDisplay.getLayout(), url, true);
653 }
654
655 public void clearRequestParameters(RenderRequest renderRequest) {
656 RenderRequestImpl renderRequestImpl = (RenderRequestImpl)renderRequest;
657
658 if (renderRequestImpl.isTriggeredByActionURL()) {
659 Map<String, String[]> renderParameters =
660 renderRequestImpl.getRenderParameters();
661
662 renderParameters.clear();
663 }
664 }
665
666 public void copyRequestParameters(
667 ActionRequest actionRequest, ActionResponse actionResponse) {
668
669 if (actionResponse instanceof StateAwareResponseImpl) {
670 StateAwareResponseImpl stateAwareResponseImpl =
671 (StateAwareResponseImpl)actionResponse;
672
673 if (stateAwareResponseImpl.getRedirectLocation() != null) {
674 if (_log.isDebugEnabled()) {
675 _log.debug(
676 "Cannot copy parameters on a redirected " +
677 "StateAwareResponseImpl");
678 }
679
680 return;
681 }
682 }
683
684 ActionResponseImpl actionResponseImpl =
685 (ActionResponseImpl)actionResponse;
686
687 Map<String, String[]> renderParameters =
688 actionResponseImpl.getRenderParameterMap();
689
690 actionResponse.setRenderParameter("p_p_lifecycle", "1");
691
692 Enumeration<String> enu = actionRequest.getParameterNames();
693
694 while (enu.hasMoreElements()) {
695 String param = enu.nextElement();
696 String[] values = actionRequest.getParameterValues(param);
697
698 if (renderParameters.get(
699 actionResponseImpl.getNamespace() + param) == null) {
700
701 actionResponse.setRenderParameter(param, values);
702 }
703 }
704 }
705
706 public String escapeRedirect(String url) {
707 if (Validator.isNull(url) || !HttpUtil.hasDomain(url)) {
708 return url;
709 }
710
711 String domain = HttpUtil.getDomain(url);
712
713 int pos = -1;
714
715 if ((pos = domain.indexOf(CharPool.COLON)) != -1) {
716 domain = domain.substring(0, pos);
717 }
718
719 try {
720 Company company = CompanyLocalServiceUtil.fetchCompanyByVirtualHost(
721 domain);
722
723 if (company != null) {
724 return url;
725 }
726 }
727 catch (Exception e) {
728 }
729
730 try {
731 LayoutSet layoutSet = LayoutSetLocalServiceUtil.fetchLayoutSet(
732 domain);
733
734 if (layoutSet != null) {
735 return url;
736 }
737 }
738 catch (Exception e) {
739 }
740
741 try {
742 String securityMode = PropsValues.REDIRECT_URL_SECURITY_MODE;
743
744 if (securityMode.equals("domain")) {
745 String[] allowedDomains =
746 PropsValues.REDIRECT_URL_DOMAINS_ALLOWED;
747
748 if ((allowedDomains.length > 0) &&
749 !ArrayUtil.contains(allowedDomains, domain)) {
750
751 if (_log.isDebugEnabled()) {
752 _log.debug("Redirect URL " + url + " is not allowed");
753 }
754
755 url = null;
756 }
757 }
758 else if (securityMode.equals("ip")) {
759 String[] allowedIps = PropsValues.REDIRECT_URL_IPS_ALLOWED;
760
761 InetAddress inetAddress = InetAddress.getByName(domain);
762
763 if ((allowedIps.length > 0) &&
764 !ArrayUtil.contains(
765 allowedIps, inetAddress.getHostAddress())) {
766
767 String serverIp = getComputerAddress();
768
769 if (!serverIp.equals(inetAddress.getHostAddress()) ||
770 !ArrayUtil.contains(allowedIps, "SERVER_IP")) {
771
772 if (_log.isDebugEnabled()) {
773 _log.debug(
774 "Redirect URL " + url + " is not allowed");
775 }
776
777 url = null;
778 }
779 }
780 }
781 }
782 catch (UnknownHostException uhe) {
783 if (_log.isDebugEnabled()) {
784 _log.debug("Unable to determine IP for redirect URL " + url);
785 }
786
787 url = null;
788 }
789
790 return url;
791 }
792
793 public String generateRandomKey(HttpServletRequest request, String input) {
794 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
795 WebKeys.THEME_DISPLAY);
796
797 if (themeDisplay.isLifecycleResource() ||
798 themeDisplay.isStateExclusive() || themeDisplay.isAjax()) {
799
800 return PwdGenerator.getPassword(PwdGenerator.KEY3, 4);
801 }
802 else {
803 return DeterminateKeyGenerator.generate(input);
804 }
805 }
806
807 public String getActualURL(
808 long groupId, boolean privateLayout, String mainPath,
809 String friendlyURL, Map<String, String[]> params,
810 Map<String, Object> requestContext)
811 throws PortalException, SystemException {
812
813 String actualURL = null;
814
815 if (friendlyURL != null) {
816 if (friendlyURL.startsWith(
817 JournalArticleConstants.CANONICAL_URL_SEPARATOR)) {
818
819 try {
820 actualURL = getJournalArticleActualURL(
821 groupId, mainPath, friendlyURL, params, requestContext);
822 }
823 catch (Exception e) {
824 throw new NoSuchLayoutException(e);
825 }
826 }
827 else if (friendlyURL.startsWith(
828 VirtualLayoutConstants.CANONICAL_URL_SEPARATOR)) {
829
830 try {
831 actualURL = getVirtualLayoutActualURL(
832 groupId, privateLayout, mainPath, friendlyURL, params,
833 requestContext);
834 }
835 catch (Exception e) {
836 throw new NoSuchLayoutException(e);
837 }
838 }
839 }
840
841 if (actualURL == null) {
842 actualURL = getLayoutActualURL(
843 groupId, privateLayout, mainPath, friendlyURL, params,
844 requestContext);
845 }
846
847 return actualURL;
848 }
849
850 public Locale[] getAlternateLocales(HttpServletRequest request)
851 throws PortalException, SystemException {
852
853 Locale[] availableLocales = LanguageUtil.getAvailableLocales();
854
855 long mainJournalArticleId = ParamUtil.getLong(request, "p_j_a_id");
856
857 if (mainJournalArticleId > 0) {
858 JournalArticle mainJournalArticle =
859 JournalArticleLocalServiceUtil.getJournalArticle(
860 mainJournalArticleId);
861
862 if (mainJournalArticle != null) {
863 String[] articleLocales =
864 mainJournalArticle.getAvailableLocales();
865
866 if (articleLocales.length > 1) {
867 Locale[] alternateLocales = new Locale[
868 availableLocales.length - articleLocales.length];
869
870 int i = 0;
871
872 for (Locale locale : availableLocales) {
873 if (!ArrayUtil.contains(
874 articleLocales,
875 LocaleUtil.toLanguageId(locale))) {
876
877 alternateLocales[i] = locale;
878
879 i++;
880 }
881 }
882
883 return alternateLocales;
884 }
885 }
886 }
887
888 return availableLocales;
889 }
890
891 public String getAlternateURL(
892 String canonicalURL, ThemeDisplay themeDisplay, Locale locale) {
893
894 LayoutSet layoutSet = themeDisplay.getLayoutSet();
895
896 String virtualHost = null;
897
898 if (Validator.isNotNull(layoutSet.getVirtualHostname())) {
899 virtualHost = layoutSet.getVirtualHostname();
900 }
901 else {
902 Company company = themeDisplay.getCompany();
903
904 virtualHost = company.getVirtualHostname();
905 }
906
907 String i18nPath = buildI18NPath(locale);
908
909 if (Validator.isNull(virtualHost)) {
910 return canonicalURL.replaceFirst(
911 _PUBLIC_GROUP_SERVLET_MAPPING,
912 i18nPath.concat(_PUBLIC_GROUP_SERVLET_MAPPING));
913 }
914
915
916
917 int pos = canonicalURL.indexOf(virtualHost);
918
919 if (pos > 0) {
920 pos += virtualHost.length();
921
922 pos = canonicalURL.indexOf(CharPool.SLASH, pos);
923
924 if ((pos > 0) && (pos < canonicalURL.length())) {
925 return canonicalURL.substring(0, pos).concat(
926 i18nPath).concat(canonicalURL.substring(pos));
927 }
928 }
929
930 return canonicalURL.concat(i18nPath);
931 }
932
933 public Set<String> getAuthTokenIgnoreActions() {
934 return _authTokenIgnoreActions;
935 }
936
937 public Set<String> getAuthTokenIgnorePortlets() {
938 return _authTokenIgnorePortlets;
939 }
940
941 public BaseModel<?> getBaseModel(ResourcePermission resourcePermission)
942 throws PortalException, SystemException {
943
944 String modelName = resourcePermission.getName();
945 String primKey = resourcePermission.getPrimKey();
946
947 return getBaseModel(modelName, primKey);
948 }
949
950 public BaseModel<?> getBaseModel(String modelName, String primKey)
951 throws PortalException, SystemException {
952
953 if (!modelName.contains(".model.")) {
954 return null;
955 }
956
957 String[] parts = StringUtil.split(modelName, CharPool.PERIOD);
958
959 if ((parts.length <= 2) || !parts[parts.length - 2].equals("model")) {
960 return null;
961 }
962
963 parts[parts.length - 2] = "service";
964
965 String serviceName =
966 StringUtil.merge(parts, StringPool.PERIOD) + "LocalServiceUtil";
967 String methodName = "get" + parts[parts.length - 1];
968
969 Method method = null;
970
971 try {
972 Class<?> serviceUtil = Class.forName(serviceName);
973
974 if (Validator.isNumber(primKey)) {
975 method = serviceUtil.getMethod(
976 methodName, new Class[] {Long.TYPE});
977
978 return (BaseModel<?>)method.invoke(null, new Long(primKey));
979 }
980 else {
981 method = serviceUtil.getMethod(
982 methodName, new Class[] {String.class});
983
984 return (BaseModel<?>)method.invoke(null, primKey);
985 }
986 }
987 catch (Exception e) {
988 Throwable cause = e.getCause();
989
990 if (cause instanceof PortalException) {
991 throw (PortalException)cause;
992 }
993 else if (cause instanceof SystemException) {
994 throw (SystemException)cause;
995 }
996 else {
997 throw new SystemException(cause);
998 }
999 }
1000 }
1001
1002 public long getBasicAuthUserId(HttpServletRequest request)
1003 throws PortalException, SystemException {
1004
1005 long companyId = PortalInstances.getCompanyId(request);
1006
1007 return getBasicAuthUserId(request, companyId);
1008 }
1009
1010 public long getBasicAuthUserId(HttpServletRequest request, long companyId)
1011 throws PortalException, SystemException {
1012
1013 long userId = 0;
1014
1015 String authorizationHeader = request.getHeader(
1016 HttpHeaders.AUTHORIZATION);
1017
1018 if (Validator.isNull(authorizationHeader)) {
1019 return userId;
1020 }
1021
1022 String[] authorizationArray = authorizationHeader.split("\\s+");
1023
1024 String authorization = authorizationArray[0];
1025 String credentials = new String(Base64.decode(authorizationArray[1]));
1026
1027 if (!authorization.equalsIgnoreCase(HttpServletRequest.BASIC_AUTH)) {
1028 return userId;
1029 }
1030
1031 String[] loginAndPassword = StringUtil.split(
1032 credentials, CharPool.COLON);
1033
1034 String login = HttpUtil.decodeURL(loginAndPassword[0].trim());
1035
1036 String password = null;
1037
1038 if (loginAndPassword.length > 1) {
1039 password = loginAndPassword[1].trim();
1040 }
1041
1042
1043
1044 if (login.endsWith("@uid")) {
1045 int pos = login.indexOf("@uid");
1046
1047 login = login.substring(0, pos);
1048 }
1049 else if (login.endsWith("@sn")) {
1050 int pos = login.indexOf("@sn");
1051
1052 login = login.substring(0, pos);
1053 }
1054
1055 try {
1056 userId = LoginUtil.getAuthenticatedUserId(
1057 request, login, password, null);
1058 }
1059 catch (AuthException ae) {
1060 }
1061
1062 return userId;
1063 }
1064
1065 public String getCanonicalURL(
1066 String completeURL, ThemeDisplay themeDisplay, Layout layout)
1067 throws PortalException, SystemException {
1068
1069 return getCanonicalURL(completeURL, themeDisplay, layout, false);
1070 }
1071
1072 public String getCanonicalURL(
1073 String completeURL, ThemeDisplay themeDisplay, Layout layout,
1074 boolean forceLayoutFriendlyURL)
1075 throws PortalException, SystemException {
1076
1077 completeURL = removeRedirectParameter(completeURL);
1078
1079 String parametersURL = StringPool.BLANK;
1080
1081 int pos = completeURL.indexOf(Portal.FRIENDLY_URL_SEPARATOR);
1082
1083 if (pos == -1) {
1084 pos = completeURL.indexOf(StringPool.QUESTION);
1085 }
1086
1087 String groupFriendlyURL = completeURL;
1088
1089 if (pos != -1) {
1090 groupFriendlyURL = completeURL.substring(0, pos);
1091
1092 parametersURL = completeURL.substring(pos);
1093 }
1094
1095 if (layout == null) {
1096 layout = themeDisplay.getLayout();
1097 }
1098
1099 String layoutFriendlyURL = StringPool.BLANK;
1100
1101 if ((groupFriendlyURL.contains(layout.getFriendlyURL()) ||
1102 groupFriendlyURL.contains(
1103 StringPool.SLASH + layout.getLayoutId())) &&
1104 (!layout.isFirstParent() || Validator.isNotNull(parametersURL))) {
1105
1106 layoutFriendlyURL = layout.getFriendlyURL();
1107 }
1108 else if (forceLayoutFriendlyURL) {
1109 layoutFriendlyURL = layout.getFriendlyURL();
1110 }
1111
1112 Group group = layout.getGroup();
1113
1114 groupFriendlyURL = getGroupFriendlyURL(
1115 group, layout.isPrivateLayout(), themeDisplay, true);
1116
1117 return groupFriendlyURL.concat(layoutFriendlyURL).concat(parametersURL);
1118 }
1119
1120
1123 public String getCDNHost() {
1124 long companyId = CompanyThreadLocal.getCompanyId();
1125
1126 return getCDNHostHttp(companyId);
1127 }
1128
1129 public String getCDNHost(boolean secure) {
1130 long companyId = CompanyThreadLocal.getCompanyId();
1131
1132 if (secure) {
1133 return getCDNHostHttps(companyId);
1134 }
1135 else {
1136 return getCDNHostHttp(companyId);
1137 }
1138 }
1139
1140 public String getCDNHost(HttpServletRequest request)
1141 throws PortalException, SystemException {
1142
1143 String cdnHost = null;
1144
1145 Company company = getCompany(request);
1146
1147 if (request.isSecure()) {
1148 cdnHost = getCDNHostHttps(company.getCompanyId());
1149 }
1150 else {
1151 cdnHost = getCDNHostHttp(company.getCompanyId());
1152 }
1153
1154 cdnHost = ParamUtil.getString(request, "cdn_host", cdnHost);
1155
1156 if (Validator.isUrl(cdnHost)) {
1157 return cdnHost;
1158 }
1159
1160 return StringPool.BLANK;
1161 }
1162
1163 public String getCDNHostHttp(long companyId) {
1164 String cdnHostHttp = _cdnHostHttpMap.get(companyId);
1165
1166 if (cdnHostHttp != null) {
1167 return cdnHostHttp;
1168 }
1169
1170 try {
1171 cdnHostHttp = PrefsPropsUtil.getString(
1172 companyId, PropsKeys.CDN_HOST_HTTP, PropsValues.CDN_HOST_HTTP);
1173 }
1174 catch (Exception e) {
1175 }
1176
1177 if ((cdnHostHttp == null) || cdnHostHttp.startsWith("${") ||
1178 !Validator.isUrl(cdnHostHttp)) {
1179
1180 cdnHostHttp = StringPool.BLANK;
1181 }
1182
1183 _cdnHostHttpMap.put(companyId, cdnHostHttp);
1184
1185 return cdnHostHttp;
1186 }
1187
1188 public String getCDNHostHttps(long companyId) {
1189 String cdnHostHttps = _cdnHostHttpsMap.get(companyId);
1190
1191 if (cdnHostHttps != null) {
1192 return cdnHostHttps;
1193 }
1194
1195 try {
1196 cdnHostHttps = PrefsPropsUtil.getString(
1197 companyId, PropsKeys.CDN_HOST_HTTPS,
1198 PropsValues.CDN_HOST_HTTPS);
1199 }
1200 catch (SystemException se) {
1201 }
1202
1203 if ((cdnHostHttps == null) || cdnHostHttps.startsWith("${") ||
1204 !Validator.isUrl(cdnHostHttps)) {
1205
1206 cdnHostHttps = StringPool.BLANK;
1207 }
1208
1209 _cdnHostHttpsMap.put(companyId, cdnHostHttps);
1210
1211 return cdnHostHttps;
1212 }
1213
1214 public String getClassName(long classNameId) {
1215 try {
1216 ClassName className = ClassNameLocalServiceUtil.getClassName(
1217 classNameId);
1218
1219 return className.getValue();
1220 }
1221 catch (Exception e) {
1222 throw new RuntimeException(
1223 "Unable to get class name from id " + classNameId);
1224 }
1225 }
1226
1227 public long getClassNameId(Class<?> clazz) {
1228 return ClassNameLocalServiceUtil.getClassNameId(clazz);
1229 }
1230
1231 public long getClassNameId(String value) {
1232 return ClassNameLocalServiceUtil.getClassNameId(value);
1233 }
1234
1235 public String getClassNamePortletId(String className) {
1236 String portletId = StringPool.BLANK;
1237
1238 if (className.startsWith("com.liferay.portlet.blogs")) {
1239 portletId = PortletKeys.BLOGS;
1240 }
1241 else if (className.startsWith("com.liferay.portlet.bookmarks")) {
1242 portletId = PortletKeys.BOOKMARKS;
1243 }
1244 else if (className.startsWith("com.liferay.portlet.calendar")) {
1245 portletId = PortletKeys.CALENDAR;
1246 }
1247 else if (className.startsWith("com.liferay.portlet.documentlibrary")) {
1248 portletId = PortletKeys.DOCUMENT_LIBRARY;
1249 }
1250 else if (className.startsWith("com.liferay.portlet.imagegallery")) {
1251 portletId = PortletKeys.MEDIA_GALLERY_DISPLAY;
1252 }
1253 else if (className.startsWith("com.liferay.portlet.journal")) {
1254 portletId = PortletKeys.JOURNAL;
1255 }
1256 else if (className.startsWith("com.liferay.portlet.messageboards")) {
1257 portletId = PortletKeys.MESSAGE_BOARDS;
1258 }
1259 else if (className.startsWith("com.liferay.portlet.wiki")) {
1260 portletId = PortletKeys.WIKI;
1261 }
1262
1263 return portletId;
1264 }
1265
1266 public Company getCompany(HttpServletRequest request)
1267 throws PortalException, SystemException {
1268
1269 long companyId = getCompanyId(request);
1270
1271 if (companyId <= 0) {
1272 return null;
1273 }
1274
1275 Company company = (Company)request.getAttribute(WebKeys.COMPANY);
1276
1277 if (company == null) {
1278
1279
1280
1281 try {
1282 company = CompanyLocalServiceUtil.getCompanyById(companyId);
1283 }
1284 catch (NoSuchCompanyException nsce) {
1285 company = CompanyLocalServiceUtil.getCompanyById(
1286 PortalInstances.getDefaultCompanyId());
1287 }
1288
1289 request.setAttribute(WebKeys.COMPANY, company);
1290 }
1291
1292 return company;
1293 }
1294
1295 public Company getCompany(PortletRequest portletRequest)
1296 throws PortalException, SystemException {
1297
1298 return getCompany(getHttpServletRequest(portletRequest));
1299 }
1300
1301 public long getCompanyId(HttpServletRequest request) {
1302 return PortalInstances.getCompanyId(request);
1303 }
1304
1305 public long getCompanyId(PortletRequest portletRequest) {
1306 return getCompanyId(getHttpServletRequest(portletRequest));
1307 }
1308
1309 public long[] getCompanyIds() {
1310 return PortalInstances.getCompanyIds();
1311 }
1312
1313 public String getComputerAddress() {
1314 return _computerAddress;
1315 }
1316
1317 public String getComputerName() {
1318 return _computerName;
1319 }
1320
1321 public String getControlPanelCategory(
1322 String portletId, ThemeDisplay themeDisplay)
1323 throws SystemException {
1324
1325 for (String category : PortletCategoryKeys.ALL) {
1326 List<Portlet> portlets = getControlPanelPortlets(
1327 category, themeDisplay);
1328
1329 for (Portlet portlet : portlets) {
1330 if (portlet.getPortletId().equals(portletId)) {
1331 return category;
1332 }
1333 }
1334 }
1335
1336 return StringPool.BLANK;
1337 }
1338
1339 public String getControlPanelFullURL(
1340 long scopeGroupId, String ppid, Map<String, String[]> params)
1341 throws PortalException, SystemException {
1342
1343 StringBundler sb = new StringBundler(6);
1344
1345 Group group = GroupLocalServiceUtil.getGroup(scopeGroupId);
1346
1347 Company company = CompanyLocalServiceUtil.getCompany(
1348 group.getCompanyId());
1349
1350 sb.append(
1351 getPortalURL(
1352 company.getVirtualHostname(), getPortalPort(false), false));
1353 sb.append(getPathFriendlyURLPrivateGroup());
1354 sb.append(GroupConstants.CONTROL_PANEL_FRIENDLY_URL);
1355 sb.append(PropsValues.CONTROL_PANEL_LAYOUT_FRIENDLY_URL);
1356
1357 if (params != null) {
1358 params = new HashMap<String, String[]>(params);
1359 }
1360 else {
1361 params = new HashMap<String, String[]>();
1362 }
1363
1364 params.put("p_p_id", new String[] {ppid});
1365 params.put("p_p_lifecycle", new String[] {"0"});
1366 params.put(
1367 "p_p_state", new String[] {WindowState.MAXIMIZED.toString()});
1368 params.put("p_p_mode", new String[] {PortletMode.VIEW.toString()});
1369
1370 sb.append(HttpUtil.parameterMapToString(params, true));
1371
1372 return sb.toString();
1373 }
1374
1375 public long getControlPanelPlid(long companyId)
1376 throws PortalException, SystemException {
1377
1378 Group controlPanelGroup = GroupLocalServiceUtil.getGroup(
1379 companyId, GroupConstants.CONTROL_PANEL);
1380
1381 return LayoutLocalServiceUtil.getDefaultPlid(
1382 controlPanelGroup.getGroupId(), true);
1383 }
1384
1385 public long getControlPanelPlid(PortletRequest portletRequest)
1386 throws PortalException, SystemException {
1387
1388 ThemeDisplay themeDisplay = (ThemeDisplay)portletRequest.getAttribute(
1389 WebKeys.THEME_DISPLAY);
1390
1391 return getControlPanelPlid(themeDisplay.getCompanyId());
1392 }
1393
1394 public Set<Portlet> getControlPanelPortlets(long companyId, String category)
1395 throws SystemException {
1396
1397 Set<Portlet> portletsSet = new TreeSet<Portlet>(
1398 new PortletControlPanelWeightComparator());
1399
1400 List<Portlet> portletsList = PortletLocalServiceUtil.getPortlets(
1401 companyId);
1402
1403 for (Portlet portlet : portletsList) {
1404 if (category.equals(portlet.getControlPanelEntryCategory())) {
1405 portletsSet.add(portlet);
1406 }
1407 }
1408
1409 return portletsSet;
1410 }
1411
1412 public List<Portlet> getControlPanelPortlets(
1413 String category, ThemeDisplay themeDisplay)
1414 throws SystemException {
1415
1416 Set<Portlet> portlets = getControlPanelPortlets(
1417 themeDisplay.getCompanyId(), category);
1418
1419 return filterControlPanelPortlets(portlets, category, themeDisplay);
1420 }
1421
1422 public String getCreateAccountURL(
1423 HttpServletRequest request, ThemeDisplay themeDisplay)
1424 throws Exception {
1425
1426 if (Validator.isNull(PropsValues.COMPANY_SECURITY_STRANGERS_URL)) {
1427 PortletURL createAccountURL = PortletURLFactoryUtil.create(
1428 request, PortletKeys.LOGIN, themeDisplay.getPlid(),
1429 PortletRequest.RENDER_PHASE);
1430
1431 createAccountURL.setWindowState(WindowState.MAXIMIZED);
1432 createAccountURL.setPortletMode(PortletMode.VIEW);
1433
1434 createAccountURL.setParameter("saveLastPath", "0");
1435 createAccountURL.setParameter(
1436 "struts_action", "/login/create_account");
1437
1438 if (!PropsValues.COMPANY_SECURITY_AUTH_REQUIRES_HTTPS) {
1439 return createAccountURL.toString();
1440 }
1441
1442 String portalURL = PortalUtil.getPortalURL(request);
1443 String portalURLSecure = PortalUtil.getPortalURL(request, true);
1444
1445 return StringUtil.replaceFirst(
1446 createAccountURL.toString(), portalURL, portalURLSecure);
1447 }
1448
1449 try {
1450 Layout layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
1451 themeDisplay.getScopeGroupId(), false,
1452 PropsValues.COMPANY_SECURITY_STRANGERS_URL);
1453
1454 return getLayoutURL(layout, themeDisplay);
1455 }
1456 catch (NoSuchLayoutException nsle) {
1457 }
1458
1459 return StringPool.BLANK;
1460 }
1461
1462 public String getCurrentCompleteURL(HttpServletRequest request) {
1463 String currentCompleteURL = (String)request.getAttribute(
1464 WebKeys.CURRENT_COMPLETE_URL);
1465
1466 if (currentCompleteURL == null) {
1467 currentCompleteURL = HttpUtil.getCompleteURL(request);
1468
1469 request.setAttribute(
1470 WebKeys.CURRENT_COMPLETE_URL, currentCompleteURL);
1471 }
1472
1473 return currentCompleteURL;
1474 }
1475
1476 public String getCurrentURL(HttpServletRequest request) {
1477 String currentURL = (String)request.getAttribute(WebKeys.CURRENT_URL);
1478
1479 if (currentURL != null) {
1480 return currentURL;
1481 }
1482
1483 currentURL = ParamUtil.getString(request, "currentURL");
1484
1485 if (Validator.isNull(currentURL)) {
1486 currentURL = HttpUtil.getCompleteURL(request);
1487
1488 if (Validator.isNotNull(currentURL) &&
1489 !currentURL.contains(_J_SECURITY_CHECK)) {
1490
1491 currentURL = currentURL.substring(
1492 currentURL.indexOf(Http.PROTOCOL_DELIMITER) +
1493 Http.PROTOCOL_DELIMITER.length());
1494
1495 currentURL = currentURL.substring(
1496 currentURL.indexOf(CharPool.SLASH));
1497 }
1498
1499 if (Validator.isNotNull(currentURL) &&
1500 FacebookUtil.isFacebook(currentURL)) {
1501
1502 String[] facebookData = FacebookUtil.getFacebookData(request);
1503
1504 if (facebookData != null) {
1505 currentURL =
1506 FacebookUtil.FACEBOOK_APPS_URL + facebookData[0] +
1507 facebookData[2];
1508 }
1509 }
1510 }
1511
1512 if (Validator.isNull(currentURL)) {
1513 currentURL = getPathMain();
1514 }
1515
1516 request.setAttribute(WebKeys.CURRENT_URL, currentURL);
1517
1518 return currentURL;
1519 }
1520
1521 public String getCurrentURL(PortletRequest portletRequest) {
1522 return (String)portletRequest.getAttribute(WebKeys.CURRENT_URL);
1523 }
1524
1525 public String getCustomSQLFunctionIsNotNull() {
1526 return PropsValues.CUSTOM_SQL_FUNCTION_ISNOTNULL;
1527 }
1528
1529 public String getCustomSQLFunctionIsNull() {
1530 return PropsValues.CUSTOM_SQL_FUNCTION_ISNULL;
1531 }
1532
1533 public Date getDate(int month, int day, int year) {
1534 try {
1535 return getDate(month, day, year, null);
1536 }
1537 catch (PortalException pe) {
1538 throw new RuntimeException();
1539 }
1540 }
1541
1542 public Date getDate(
1543 int month, int day, int year,
1544 Class<? extends PortalException> clazz)
1545 throws PortalException {
1546
1547 return getDate(month, day, year, null, clazz);
1548 }
1549
1550 public Date getDate(
1551 int month, int day, int year, int hour, int min,
1552 Class<? extends PortalException> clazz)
1553 throws PortalException {
1554
1555 return getDate(month, day, year, hour, min, null, clazz);
1556 }
1557
1558 public Date getDate(
1559 int month, int day, int year, int hour, int min, TimeZone timeZone,
1560 Class<? extends PortalException> clazz)
1561 throws PortalException {
1562
1563 if (!Validator.isGregorianDate(month, day, year)) {
1564 if (clazz != null) {
1565 try {
1566 throw clazz.newInstance();
1567 }
1568 catch (Exception e) {
1569 throw new PortalException(e);
1570 }
1571 }
1572 else {
1573 return null;
1574 }
1575 }
1576 else {
1577 Calendar cal = null;
1578
1579 if (timeZone == null) {
1580 cal = CalendarFactoryUtil.getCalendar();
1581 }
1582 else {
1583 cal = CalendarFactoryUtil.getCalendar(timeZone);
1584 }
1585
1586 if ((hour == -1) || (min == -1)) {
1587 cal.set(year, month, day, 0, 0, 0);
1588 }
1589 else {
1590 cal.set(year, month, day, hour, min, 0);
1591 }
1592
1593 cal.set(Calendar.MILLISECOND, 0);
1594
1595 Date date = cal.getTime();
1596
1597
1602
1603 return date;
1604 }
1605 }
1606
1607 public Date getDate(
1608 int month, int day, int year, TimeZone timeZone,
1609 Class<? extends PortalException> clazz)
1610 throws PortalException {
1611
1612 return getDate(month, day, year, -1, -1, timeZone, clazz);
1613 }
1614
1615 public long getDefaultCompanyId() {
1616 return PortalInstances.getDefaultCompanyId();
1617 }
1618
1619 public long getDigestAuthUserId(HttpServletRequest request)
1620 throws PortalException, SystemException {
1621
1622 long userId = 0;
1623
1624 String authorizationHeader = request.getHeader(
1625 HttpHeaders.AUTHORIZATION);
1626
1627 if (Validator.isNull(authorizationHeader) ||
1628 !authorizationHeader.startsWith("Digest ")) {
1629
1630 return userId;
1631 }
1632
1633 authorizationHeader = authorizationHeader.substring("Digest ".length());
1634 authorizationHeader = StringUtil.replace(
1635 authorizationHeader, CharPool.COMMA, CharPool.NEW_LINE);
1636
1637 UnicodeProperties authorizationProperties = new UnicodeProperties();
1638
1639 authorizationProperties.fastLoad(authorizationHeader);
1640
1641 String username = StringUtil.unquote(
1642 authorizationProperties.getProperty("username"));
1643 String realm = StringUtil.unquote(
1644 authorizationProperties.getProperty("realm"));
1645 String nonce = StringUtil.unquote(
1646 authorizationProperties.getProperty("nonce"));
1647 String uri = StringUtil.unquote(
1648 authorizationProperties.getProperty("uri"));
1649 String response = StringUtil.unquote(
1650 authorizationProperties.getProperty("response"));
1651
1652 if (Validator.isNull(username) || Validator.isNull(realm) ||
1653 Validator.isNull(nonce) || Validator.isNull(uri) ||
1654 Validator.isNull(response)) {
1655
1656 return userId;
1657 }
1658
1659 if (!realm.equals(PORTAL_REALM) ||
1660 !uri.equals(request.getRequestURI())) {
1661
1662 return userId;
1663 }
1664
1665 if (!NonceUtil.verify(nonce)) {
1666 return userId;
1667 }
1668
1669 long companyId = PortalInstances.getCompanyId(request);
1670
1671 userId = UserLocalServiceUtil.authenticateForDigest(
1672 companyId, username, realm, nonce, request.getMethod(), uri,
1673 response);
1674
1675 return userId;
1676 }
1677
1678 public String getEmailFromAddress(
1679 PortletPreferences preferences, long companyId, String defaultValue)
1680 throws SystemException {
1681
1682 if (Validator.isNull(defaultValue)) {
1683 defaultValue = PrefsPropsUtil.getString(
1684 companyId, PropsKeys.ADMIN_EMAIL_FROM_ADDRESS);
1685 }
1686
1687 return preferences.getValue("emailFromAddress", defaultValue);
1688 }
1689
1690 public String getEmailFromName(
1691 PortletPreferences preferences, long companyId, String defaultValue)
1692 throws SystemException {
1693
1694 if (Validator.isNull(defaultValue)) {
1695 defaultValue = PrefsPropsUtil.getString(
1696 companyId, PropsKeys.ADMIN_EMAIL_FROM_NAME);
1697 }
1698
1699 return preferences.getValue("emailFromName", defaultValue);
1700 }
1701
1702 public Map<String, Serializable> getExpandoBridgeAttributes(
1703 ExpandoBridge expandoBridge, PortletRequest portletRequest)
1704 throws PortalException, SystemException {
1705
1706 Map<String, Serializable> attributes =
1707 new HashMap<String, Serializable>();
1708
1709 List<String> names = new ArrayList<String>();
1710
1711 Enumeration<String> enu = portletRequest.getParameterNames();
1712
1713 while (enu.hasMoreElements()) {
1714 String param = enu.nextElement();
1715
1716 if (param.contains("ExpandoAttributeName--")) {
1717 String name = ParamUtil.getString(portletRequest, param);
1718
1719 names.add(name);
1720 }
1721 }
1722
1723 for (String name : names) {
1724 int type = expandoBridge.getAttributeType(name);
1725
1726 UnicodeProperties properties = expandoBridge.getAttributeProperties(
1727 name);
1728
1729 String displayType = GetterUtil.getString(
1730 properties.getProperty(
1731 ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE),
1732 ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX);
1733
1734 Serializable value = getExpandoValue(
1735 portletRequest, "ExpandoAttribute--" + name + "--", type,
1736 displayType);
1737
1738 attributes.put(name, value);
1739 }
1740
1741 return attributes;
1742 }
1743
1744 public Map<String, Serializable> getExpandoBridgeAttributes(
1745 ExpandoBridge expandoBridge,
1746 UploadPortletRequest uploadPortletRequest)
1747 throws PortalException, SystemException {
1748
1749 Map<String, Serializable> attributes =
1750 new HashMap<String, Serializable>();
1751
1752 List<String> names = new ArrayList<String>();
1753
1754 Enumeration<String> enu = uploadPortletRequest.getParameterNames();
1755
1756 while (enu.hasMoreElements()) {
1757 String param = enu.nextElement();
1758
1759 if (param.contains("ExpandoAttributeName--")) {
1760 String name = ParamUtil.getString(uploadPortletRequest, param);
1761
1762 names.add(name);
1763 }
1764 }
1765
1766 for (String name : names) {
1767 int type = expandoBridge.getAttributeType(name);
1768
1769 UnicodeProperties properties = expandoBridge.getAttributeProperties(
1770 name);
1771
1772 String displayType = GetterUtil.getString(
1773 properties.getProperty(
1774 ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE),
1775 ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX);
1776
1777 Serializable value = getExpandoValue(
1778 uploadPortletRequest, "ExpandoAttribute--" + name + "--", type,
1779 displayType);
1780
1781 attributes.put(name, value);
1782 }
1783
1784 return attributes;
1785 }
1786
1787 public Serializable getExpandoValue(
1788 PortletRequest portletRequest, String name, int type,
1789 String displayType)
1790 throws PortalException, SystemException {
1791
1792 Serializable value = null;
1793
1794 if (type == ExpandoColumnConstants.BOOLEAN) {
1795 value = ParamUtil.getBoolean(portletRequest, name);
1796 }
1797 else if (type == ExpandoColumnConstants.BOOLEAN_ARRAY) {
1798 }
1799 else if (type == ExpandoColumnConstants.DATE) {
1800 int valueDateMonth = ParamUtil.getInteger(
1801 portletRequest, name + "Month");
1802 int valueDateDay = ParamUtil.getInteger(
1803 portletRequest, name + "Day");
1804 int valueDateYear = ParamUtil.getInteger(
1805 portletRequest, name + "Year");
1806 int valueDateHour = ParamUtil.getInteger(
1807 portletRequest, name + "Hour");
1808 int valueDateMinute = ParamUtil.getInteger(
1809 portletRequest, name + "Minute");
1810 int valueDateAmPm = ParamUtil.getInteger(
1811 portletRequest, name + "AmPm");
1812
1813 if (valueDateAmPm == Calendar.PM) {
1814 valueDateHour += 12;
1815 }
1816
1817 TimeZone timeZone = null;
1818
1819 User user = getUser(portletRequest);
1820
1821 if (user != null) {
1822 timeZone = user.getTimeZone();
1823 }
1824
1825 value = getDate(
1826 valueDateMonth, valueDateDay, valueDateYear, valueDateHour,
1827 valueDateMinute, timeZone, ValueDataException.class);
1828 }
1829 else if (type == ExpandoColumnConstants.DATE_ARRAY) {
1830 }
1831 else if (type == ExpandoColumnConstants.DOUBLE) {
1832 value = ParamUtil.getDouble(portletRequest, name);
1833 }
1834 else if (type == ExpandoColumnConstants.DOUBLE_ARRAY) {
1835 String[] values = portletRequest.getParameterValues(name);
1836
1837 if (displayType.equals(
1838 ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
1839
1840 values = StringUtil.splitLines(values[0]);
1841 }
1842
1843 value = GetterUtil.getDoubleValues(values);
1844 }
1845 else if (type == ExpandoColumnConstants.FLOAT) {
1846 value = ParamUtil.getFloat(portletRequest, name);
1847 }
1848 else if (type == ExpandoColumnConstants.FLOAT_ARRAY) {
1849 String[] values = portletRequest.getParameterValues(name);
1850
1851 if (displayType.equals(
1852 ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
1853
1854 values = StringUtil.splitLines(values[0]);
1855 }
1856
1857 value = GetterUtil.getFloatValues(values);
1858 }
1859 else if (type == ExpandoColumnConstants.INTEGER) {
1860 value = ParamUtil.getInteger(portletRequest, name);
1861 }
1862 else if (type == ExpandoColumnConstants.INTEGER_ARRAY) {
1863 String[] values = portletRequest.getParameterValues(name);
1864
1865 if (displayType.equals(
1866 ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
1867
1868 values = StringUtil.splitLines(values[0]);
1869 }
1870
1871 value = GetterUtil.getIntegerValues(values);
1872 }
1873 else if (type == ExpandoColumnConstants.LONG) {
1874 value = ParamUtil.getLong(portletRequest, name);
1875 }
1876 else if (type == ExpandoColumnConstants.LONG_ARRAY) {
1877 String[] values = portletRequest.getParameterValues(name);
1878
1879 if (displayType.equals(
1880 ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
1881
1882 values = StringUtil.splitLines(values[0]);
1883 }
1884
1885 value = GetterUtil.getLongValues(values);
1886 }
1887 else if (type == ExpandoColumnConstants.NUMBER) {
1888 value = ParamUtil.getNumber(portletRequest, name);
1889 }
1890 else if (type == ExpandoColumnConstants.NUMBER_ARRAY) {
1891 String[] values = portletRequest.getParameterValues(name);
1892
1893 if (displayType.equals(
1894 ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
1895
1896 values = StringUtil.splitLines(values[0]);
1897 }
1898
1899 value = GetterUtil.getNumberValues(values);
1900 }
1901 else if (type == ExpandoColumnConstants.SHORT) {
1902 value = ParamUtil.getShort(portletRequest, name);
1903 }
1904 else if (type == ExpandoColumnConstants.SHORT_ARRAY) {
1905 String[] values = portletRequest.getParameterValues(name);
1906
1907 if (displayType.equals(
1908 ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
1909
1910 values = StringUtil.splitLines(values[0]);
1911 }
1912
1913 value = GetterUtil.getShortValues(values);
1914 }
1915 else if (type == ExpandoColumnConstants.STRING_ARRAY) {
1916 value = portletRequest.getParameterValues(name);
1917 }
1918 else {
1919 value = ParamUtil.getString(portletRequest, name);
1920 }
1921
1922 return value;
1923 }
1924
1925 public Serializable getExpandoValue(
1926 UploadPortletRequest uploadPortletRequest, String name, int type,
1927 String displayType)
1928 throws PortalException, SystemException {
1929
1930 Serializable value = null;
1931
1932 if (type == ExpandoColumnConstants.BOOLEAN) {
1933 value = ParamUtil.getBoolean(uploadPortletRequest, name);
1934 }
1935 else if (type == ExpandoColumnConstants.BOOLEAN_ARRAY) {
1936 }
1937 else if (type == ExpandoColumnConstants.DATE) {
1938 int valueDateMonth = ParamUtil.getInteger(
1939 uploadPortletRequest, name + "Month");
1940 int valueDateDay = ParamUtil.getInteger(
1941 uploadPortletRequest, name + "Day");
1942 int valueDateYear = ParamUtil.getInteger(
1943 uploadPortletRequest, name + "Year");
1944 int valueDateHour = ParamUtil.getInteger(
1945 uploadPortletRequest, name + "Hour");
1946 int valueDateMinute = ParamUtil.getInteger(
1947 uploadPortletRequest, name + "Minute");
1948 int valueDateAmPm = ParamUtil.getInteger(
1949 uploadPortletRequest, name + "AmPm");
1950
1951 if (valueDateAmPm == Calendar.PM) {
1952 valueDateHour += 12;
1953 }
1954
1955 TimeZone timeZone = null;
1956
1957 User user = getUser(uploadPortletRequest);
1958
1959 if (user != null) {
1960 timeZone = user.getTimeZone();
1961 }
1962
1963 value = getDate(
1964 valueDateMonth, valueDateDay, valueDateYear, valueDateHour,
1965 valueDateMinute, timeZone, ValueDataException.class);
1966 }
1967 else if (type == ExpandoColumnConstants.DATE_ARRAY) {
1968 }
1969 else if (type == ExpandoColumnConstants.DOUBLE) {
1970 value = ParamUtil.getDouble(uploadPortletRequest, name);
1971 }
1972 else if (type == ExpandoColumnConstants.DOUBLE_ARRAY) {
1973 String[] values = uploadPortletRequest.getParameterValues(name);
1974
1975 if (displayType.equals(
1976 ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
1977
1978 values = StringUtil.splitLines(values[0]);
1979 }
1980
1981 value = GetterUtil.getDoubleValues(values);
1982 }
1983 else if (type == ExpandoColumnConstants.FLOAT) {
1984 value = ParamUtil.getFloat(uploadPortletRequest, name);
1985 }
1986 else if (type == ExpandoColumnConstants.FLOAT_ARRAY) {
1987 String[] values = uploadPortletRequest.getParameterValues(name);
1988
1989 if (displayType.equals(
1990 ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
1991
1992 values = StringUtil.splitLines(values[0]);
1993 }
1994
1995 value = GetterUtil.getFloatValues(values);
1996 }
1997 else if (type == ExpandoColumnConstants.INTEGER) {
1998 value = ParamUtil.getInteger(uploadPortletRequest, name);
1999 }
2000 else if (type == ExpandoColumnConstants.INTEGER_ARRAY) {
2001 String[] values = uploadPortletRequest.getParameterValues(name);
2002
2003 if (displayType.equals(
2004 ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
2005
2006 values = StringUtil.splitLines(values[0]);
2007 }
2008
2009 value = GetterUtil.getIntegerValues(values);
2010 }
2011 else if (type == ExpandoColumnConstants.LONG) {
2012 value = ParamUtil.getLong(uploadPortletRequest, name);
2013 }
2014 else if (type == ExpandoColumnConstants.LONG_ARRAY) {
2015 String[] values = uploadPortletRequest.getParameterValues(name);
2016
2017 if (displayType.equals(
2018 ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
2019
2020 values = StringUtil.splitLines(values[0]);
2021 }
2022
2023 value = GetterUtil.getLongValues(values);
2024 }
2025 else if (type == ExpandoColumnConstants.SHORT) {
2026 value = ParamUtil.getShort(uploadPortletRequest, name);
2027 }
2028 else if (type == ExpandoColumnConstants.SHORT_ARRAY) {
2029 String[] values = uploadPortletRequest.getParameterValues(name);
2030
2031 if (displayType.equals(
2032 ExpandoColumnConstants.PROPERTY_DISPLAY_TYPE_TEXT_BOX)) {
2033
2034 values = StringUtil.splitLines(values[0]);
2035 }
2036
2037 value = GetterUtil.getShortValues(values);
2038 }
2039 else if (type == ExpandoColumnConstants.STRING_ARRAY) {
2040 value = uploadPortletRequest.getParameterValues(name);
2041 }
2042 else {
2043 value = ParamUtil.getString(uploadPortletRequest, name);
2044 }
2045
2046 return value;
2047 }
2048
2049 public String getFacebookURL(
2050 Portlet portlet, String facebookCanvasPageURL,
2051 ThemeDisplay themeDisplay)
2052 throws PortalException, SystemException {
2053
2054 String facebookURL = getServletURL(
2055 portlet, FacebookUtil.FACEBOOK_SERVLET_PATH + facebookCanvasPageURL,
2056 themeDisplay);
2057
2058 if (!facebookURL.endsWith(StringPool.SLASH)) {
2059 facebookURL += StringPool.SLASH;
2060 }
2061
2062 return facebookURL;
2063 }
2064
2065 public String getFirstPageLayoutTypes(PageContext pageContext) {
2066 StringBundler sb = new StringBundler();
2067
2068 for (String type : PropsValues.LAYOUT_TYPES) {
2069 if (isLayoutFirstPageable(type)) {
2070 sb.append(
2071 LanguageUtil.get(pageContext, "layout.types." + type));
2072 sb.append(StringPool.COMMA);
2073 sb.append(StringPool.SPACE);
2074 }
2075 }
2076
2077 if (sb.index() >= 2) {
2078 sb.setIndex(sb.index() - 2);
2079 }
2080
2081 return sb.toString();
2082 }
2083
2084 public String getGlobalLibDir() {
2085 return PropsValues.LIFERAY_LIB_GLOBAL_DIR;
2086 }
2087
2088 public String getGoogleGadgetURL(Portlet portlet, ThemeDisplay themeDisplay)
2089 throws PortalException, SystemException {
2090
2091 return getServletURL(
2092 portlet, PropsValues.GOOGLE_GADGET_SERVLET_MAPPING, themeDisplay);
2093 }
2094
2095 public String getGroupFriendlyURL(
2096 Group group, boolean privateLayoutSet, ThemeDisplay themeDisplay)
2097 throws PortalException, SystemException {
2098
2099 return getGroupFriendlyURL(
2100 group, privateLayoutSet, themeDisplay, false);
2101 }
2102
2103 public String[] getGroupPermissions(HttpServletRequest request) {
2104 return request.getParameterValues("groupPermissions");
2105 }
2106
2107 public String[] getGroupPermissions(PortletRequest portletRequest) {
2108 return portletRequest.getParameterValues("groupPermissions");
2109 }
2110
2111 public String[] getGuestPermissions(HttpServletRequest request) {
2112 return request.getParameterValues("guestPermissions");
2113 }
2114
2115 public String[] getGuestPermissions(PortletRequest portletRequest) {
2116 return portletRequest.getParameterValues("guestPermissions");
2117 }
2118
2119 public String getHomeURL(HttpServletRequest request)
2120 throws PortalException, SystemException {
2121
2122 String portalURL = getPortalURL(request);
2123
2124 return portalURL + _pathContext + getRelativeHomeURL(request);
2125 }
2126
2127 public String getHost(HttpServletRequest request) {
2128 request = getOriginalServletRequest(request);
2129
2130 String host = request.getHeader("Host");
2131
2132 if (host != null) {
2133 host = host.trim().toLowerCase();
2134
2135 int pos = host.indexOf(':');
2136
2137 if (pos >= 0) {
2138 host = host.substring(0, pos);
2139 }
2140 }
2141 else {
2142 host = null;
2143 }
2144
2145 return host;
2146 }
2147
2148 public String getHost(PortletRequest portletRequest) {
2149 return getHost(getHttpServletRequest(portletRequest));
2150 }
2151
2152 public HttpServletRequest getHttpServletRequest(
2153 PortletRequest portletRequest) {
2154
2155 PortletRequestImpl portletRequestImpl =
2156 PortletRequestImpl.getPortletRequestImpl(portletRequest);
2157
2158 return portletRequestImpl.getHttpServletRequest();
2159 }
2160
2161 public HttpServletResponse getHttpServletResponse(
2162 PortletResponse portletResponse) {
2163
2164 PortletResponseImpl portletResponseImpl =
2165 PortletResponseImpl.getPortletResponseImpl(portletResponse);
2166
2167 return portletResponseImpl.getHttpServletResponse();
2168 }
2169
2170 public String getJournalArticleActualURL(
2171 long groupId, String mainPath, String friendlyURL,
2172 Map<String, String[]> params, Map<String, Object> requestContext)
2173 throws PortalException, SystemException {
2174
2175 String articleUrlTitle = friendlyURL.substring(
2176 JournalArticleConstants.CANONICAL_URL_SEPARATOR.length());
2177
2178 JournalArticle journalArticle =
2179 JournalArticleLocalServiceUtil.getArticleByUrlTitle(
2180 groupId, articleUrlTitle);
2181
2182 Layout layout = LayoutLocalServiceUtil.getLayoutByUuidAndGroupId(
2183 journalArticle.getLayoutUuid(), groupId);
2184
2185 String layoutActualURL = getLayoutActualURL(layout, mainPath);
2186
2187 InheritableMap<String, String[]> actualParams =
2188 new InheritableMap<String, String[]>();
2189
2190 if (params != null) {
2191 actualParams.setParentMap(params);
2192 }
2193
2194 UnicodeProperties typeSettingsProperties =
2195 layout.getTypeSettingsProperties();
2196
2197 String defaultAssetPublisherPortletId = typeSettingsProperties.get(
2198 LayoutTypePortletConstants.DEFAULT_ASSET_PUBLISHER_PORTLET_ID);
2199
2200 String currentDefaultAssetPublisherPortletId =
2201 defaultAssetPublisherPortletId;
2202
2203 if (Validator.isNull(defaultAssetPublisherPortletId)) {
2204 String instanceId = LayoutTypePortletImpl.generateInstanceId();
2205
2206 defaultAssetPublisherPortletId = PortletConstants.assemblePortletId(
2207 PortletKeys.ASSET_PUBLISHER, instanceId);
2208 }
2209
2210 HttpServletRequest request = (HttpServletRequest)requestContext.get(
2211 "request");
2212
2213 if (Validator.isNull(currentDefaultAssetPublisherPortletId)) {
2214 String actualPortletAuthenticationToken = AuthTokenUtil.getToken(
2215 request, layout.getPlid(), defaultAssetPublisherPortletId);
2216
2217 actualParams.put(
2218 "p_p_auth", new String[] {actualPortletAuthenticationToken});
2219 }
2220
2221 actualParams.put(
2222 "p_p_id", new String[] {defaultAssetPublisherPortletId});
2223 actualParams.put("p_p_lifecycle", new String[] {"0"});
2224
2225 if (Validator.isNull(currentDefaultAssetPublisherPortletId)) {
2226 actualParams.put(
2227 "p_p_state", new String[] {WindowState.MAXIMIZED.toString()});
2228 }
2229
2230 actualParams.put("p_p_mode", new String[] {"view"});
2231 actualParams.put(
2232 "p_j_a_id", new String[] {String.valueOf(journalArticle.getId())});
2233
2234 String namespace = getPortletNamespace(defaultAssetPublisherPortletId);
2235
2236 actualParams.put(
2237 namespace + "struts_action",
2238 new String[] {"/asset_publisher/view_content"});
2239 actualParams.put(
2240 namespace + "type",
2241 new String[] {JournalArticleAssetRendererFactory.TYPE});
2242 actualParams.put(
2243 namespace + "urlTitle",
2244 new String[] {journalArticle.getUrlTitle()});
2245
2246 String queryString = HttpUtil.parameterMapToString(actualParams, false);
2247
2248 if (layoutActualURL.contains(StringPool.QUESTION)) {
2249 layoutActualURL =
2250 layoutActualURL + StringPool.AMPERSAND + queryString;
2251 }
2252 else {
2253 layoutActualURL =
2254 layoutActualURL + StringPool.QUESTION + queryString;
2255 }
2256
2257 Locale locale = getLocale(request);
2258
2259 addPageSubtitle(journalArticle.getTitle(locale), request);
2260 addPageDescription(journalArticle.getDescription(locale), request);
2261
2262 List<AssetTag> assetTags = AssetTagLocalServiceUtil.getTags(
2263 JournalArticle.class.getName(), journalArticle.getPrimaryKey());
2264
2265 if (!assetTags.isEmpty()) {
2266 addPageKeywords(
2267 ListUtil.toString(assetTags, AssetTag.NAME_ACCESSOR), request);
2268 }
2269
2270 return layoutActualURL;
2271 }
2272
2273 public String getJsSafePortletId(String portletId) {
2274 return JS.getSafeName(portletId);
2275 }
2276
2277 public String getLayoutActualURL(Layout layout) {
2278 return getLayoutActualURL(layout, getPathMain());
2279 }
2280
2281 public String getLayoutActualURL(Layout layout, String mainPath) {
2282 Map<String, String> variables = new HashMap<String, String>();
2283
2284 variables.put("liferay:groupId", String.valueOf(layout.getGroupId()));
2285 variables.put("liferay:mainPath", mainPath);
2286 variables.put("liferay:plid", String.valueOf(layout.getPlid()));
2287
2288 if (layout instanceof VirtualLayout) {
2289 variables.put(
2290 "liferay:pvlsgid", String.valueOf(layout.getGroupId()));
2291 }
2292 else {
2293 variables.put("liferay:pvlsgid", "0");
2294 }
2295
2296 LayoutType layoutType = layout.getLayoutType();
2297
2298 UnicodeProperties typeSettingsProperties =
2299 layoutType.getTypeSettingsProperties();
2300
2301 variables.putAll(typeSettingsProperties);
2302
2303 LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
2304
2305 return layoutSettings.getURL(variables);
2306 }
2307
2308 public String getLayoutActualURL(
2309 long groupId, boolean privateLayout, String mainPath,
2310 String friendlyURL)
2311 throws PortalException, SystemException {
2312
2313 return getLayoutActualURL(
2314 groupId, privateLayout, mainPath, friendlyURL, null, null);
2315 }
2316
2317 public String getLayoutActualURL(
2318 long groupId, boolean privateLayout, String mainPath,
2319 String friendlyURL, Map<String, String[]> params,
2320 Map<String, Object> requestContext)
2321 throws PortalException, SystemException {
2322
2323 Layout layout = null;
2324 String queryString = StringPool.BLANK;
2325
2326 if (Validator.isNull(friendlyURL)) {
2327 List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
2328 groupId, privateLayout,
2329 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID);
2330
2331 if (!layouts.isEmpty()) {
2332 layout = layouts.get(0);
2333 }
2334 else {
2335 throw new NoSuchLayoutException(
2336 "{groupId=" + groupId + ",privateLayout=" + privateLayout +
2337 "} does not have any layouts");
2338 }
2339 }
2340 else {
2341 Object[] friendlyURLMapper = getPortletFriendlyURLMapper(
2342 groupId, privateLayout, friendlyURL, params, requestContext);
2343
2344 layout = (Layout)friendlyURLMapper[0];
2345 queryString = (String)friendlyURLMapper[1];
2346 }
2347
2348 String layoutActualURL = getLayoutActualURL(layout, mainPath);
2349
2350 if (Validator.isNotNull(queryString)) {
2351 layoutActualURL = layoutActualURL.concat(queryString);
2352 }
2353 else if (params.isEmpty()) {
2354 LayoutType layoutType = layout.getLayoutType();
2355
2356 UnicodeProperties typeSettingsProperties =
2357 layoutType.getTypeSettingsProperties();
2358
2359 queryString = typeSettingsProperties.getProperty("query-string");
2360
2361 if (Validator.isNotNull(queryString) &&
2362 layoutActualURL.contains(StringPool.QUESTION)) {
2363
2364 layoutActualURL = layoutActualURL.concat(
2365 StringPool.AMPERSAND).concat(queryString);
2366 }
2367 }
2368
2369 return layoutActualURL;
2370 }
2371
2372 public String getLayoutEditPage(Layout layout) {
2373 LayoutSettings layoutSettings = LayoutSettings.getInstance(
2374 layout.getType());
2375
2376 return layoutSettings.getEditPage();
2377 }
2378
2379 public String getLayoutEditPage(String type) {
2380 LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
2381
2382 return layoutSettings.getEditPage();
2383 }
2384
2385 public String getLayoutFriendlyURL(Layout layout, ThemeDisplay themeDisplay)
2386 throws PortalException, SystemException {
2387
2388 if (!isLayoutFriendliable(layout)) {
2389 return null;
2390 }
2391
2392 String groupFriendlyURL = getGroupFriendlyURL(
2393 layout.getGroup(), layout.isPrivateLayout(), themeDisplay);
2394
2395 return groupFriendlyURL.concat(layout.getFriendlyURL());
2396 }
2397
2398 public String getLayoutFriendlyURL(
2399 Layout layout, ThemeDisplay themeDisplay, Locale locale)
2400 throws PortalException, SystemException {
2401
2402 String i18nLanguageId = themeDisplay.getI18nLanguageId();
2403 String i18nPath = themeDisplay.getI18nPath();
2404
2405 try {
2406 String tempI18nLanguageId = null;
2407 String tempI18nPath = null;
2408
2409 if ((I18nFilter.getLanguageIds().contains(locale.toString()) &&
2410 ((PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 1) &&
2411 !locale.equals(LocaleUtil.getDefault()))) ||
2412 (PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 2)) {
2413
2414 tempI18nLanguageId = locale.toString();
2415 tempI18nPath = buildI18NPath(locale);
2416 }
2417
2418 themeDisplay.setI18nLanguageId(tempI18nLanguageId);
2419 themeDisplay.setI18nPath(tempI18nPath);
2420
2421 return getLayoutFriendlyURL(layout, themeDisplay);
2422 }
2423 finally {
2424 themeDisplay.setI18nLanguageId(i18nLanguageId);
2425 themeDisplay.setI18nPath(i18nPath);
2426 }
2427 }
2428
2429 public String getLayoutFullURL(Layout layout, ThemeDisplay themeDisplay)
2430 throws PortalException, SystemException {
2431
2432 return getLayoutFullURL(layout, themeDisplay, true);
2433 }
2434
2435 public String getLayoutFullURL(
2436 Layout layout, ThemeDisplay themeDisplay, boolean doAsUser)
2437 throws PortalException, SystemException {
2438
2439 String layoutURL = getLayoutURL(layout, themeDisplay, doAsUser);
2440 String portalURL = getPortalURL(layout, themeDisplay);
2441
2442 if (StringUtil.startsWith(layoutURL, portalURL)) {
2443 return layoutURL;
2444 }
2445 else {
2446 return portalURL + layoutURL;
2447 }
2448 }
2449
2450 public String getLayoutFullURL(long groupId, String portletId)
2451 throws PortalException, SystemException {
2452
2453 return getLayoutFullURL(groupId, portletId, false);
2454 }
2455
2456 public String getLayoutFullURL(
2457 long groupId, String portletId, boolean secure)
2458 throws PortalException, SystemException {
2459
2460 long plid = getPlidFromPortletId(groupId, portletId);
2461
2462 if (plid == LayoutConstants.DEFAULT_PLID) {
2463 return null;
2464 }
2465
2466 StringBundler sb = new StringBundler(4);
2467
2468 Layout layout = LayoutLocalServiceUtil.getLayout(plid);
2469
2470 Group group = GroupLocalServiceUtil.getGroup(groupId);
2471
2472 if (group.isLayout()) {
2473 long parentGroupId = group.getParentGroupId();
2474
2475 if (parentGroupId > 0) {
2476 group = GroupLocalServiceUtil.getGroup(parentGroupId);
2477 }
2478 }
2479
2480 String virtualHostname = null;
2481
2482 LayoutSet layoutSet = layout.getLayoutSet();
2483
2484 if (Validator.isNotNull(layoutSet.getVirtualHostname())) {
2485 virtualHostname = layoutSet.getVirtualHostname();
2486 }
2487 else {
2488 Company company = CompanyLocalServiceUtil.getCompany(
2489 layout.getCompanyId());
2490
2491 virtualHostname = company.getVirtualHostname();
2492 }
2493
2494 String portalURL = getPortalURL(
2495 virtualHostname, getPortalPort(secure), secure);
2496
2497 sb.append(portalURL);
2498
2499 if (layout.isPrivateLayout()) {
2500 if (group.isUser()) {
2501 sb.append(getPathFriendlyURLPrivateUser());
2502 }
2503 else {
2504 sb.append(getPathFriendlyURLPrivateGroup());
2505 }
2506 }
2507 else {
2508 sb.append(getPathFriendlyURLPublic());
2509 }
2510
2511 sb.append(group.getFriendlyURL());
2512 sb.append(layout.getFriendlyURL());
2513
2514 return sb.toString();
2515 }
2516
2517 public String getLayoutFullURL(ThemeDisplay themeDisplay)
2518 throws PortalException, SystemException {
2519
2520 return getLayoutFullURL(themeDisplay.getLayout(), themeDisplay);
2521 }
2522
2523 public String getLayoutSetFriendlyURL(
2524 LayoutSet layoutSet, ThemeDisplay themeDisplay)
2525 throws PortalException, SystemException {
2526
2527 String virtualHostname = layoutSet.getVirtualHostname();
2528
2529 if (Validator.isNull(virtualHostname) &&
2530 Validator.isNotNull(PropsValues.VIRTUAL_HOSTS_DEFAULT_SITE_NAME) &&
2531 !layoutSet.isPrivateLayout()) {
2532
2533 try {
2534 Group group = GroupLocalServiceUtil.getGroup(
2535 themeDisplay.getCompanyId(),
2536 PropsValues.VIRTUAL_HOSTS_DEFAULT_SITE_NAME);
2537
2538 if (layoutSet.getGroupId() == group.getGroupId()) {
2539 Company company = themeDisplay.getCompany();
2540
2541 virtualHostname = company.getVirtualHostname();
2542 }
2543 }
2544 catch (Exception e) {
2545 _log.error(e, e);
2546 }
2547 }
2548
2549 if (Validator.isNotNull(virtualHostname)) {
2550 String portalURL = getPortalURL(
2551 virtualHostname, themeDisplay.getServerPort(),
2552 themeDisplay.isSecure());
2553
2554
2555
2556
2557 long curLayoutSetId =
2558 themeDisplay.getLayout().getLayoutSet().getLayoutSetId();
2559
2560 if ((layoutSet.getLayoutSetId() != curLayoutSetId) ||
2561 portalURL.startsWith(themeDisplay.getURLPortal())) {
2562
2563 String layoutSetFriendlyURL = StringPool.BLANK;
2564
2565 if (themeDisplay.isI18n()) {
2566 layoutSetFriendlyURL = themeDisplay.getI18nPath();
2567 }
2568
2569 return portalURL + _pathContext + layoutSetFriendlyURL;
2570 }
2571 }
2572
2573 Group group = GroupLocalServiceUtil.getGroup(layoutSet.getGroupId());
2574
2575 String friendlyURL = null;
2576
2577 if (layoutSet.isPrivateLayout()) {
2578 if (group.isUser()) {
2579 friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
2580 }
2581 else {
2582 friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
2583 }
2584 }
2585 else {
2586 friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
2587 }
2588
2589 if (themeDisplay.isI18n()) {
2590 friendlyURL = themeDisplay.getI18nPath() + friendlyURL;
2591 }
2592
2593 return _pathContext + friendlyURL + group.getFriendlyURL();
2594 }
2595
2596 public String getLayoutTarget(Layout layout) {
2597 UnicodeProperties typeSettingsProps =
2598 layout.getTypeSettingsProperties();
2599
2600 String target = typeSettingsProps.getProperty("target");
2601
2602 if (Validator.isNull(target)) {
2603 target = StringPool.BLANK;
2604 }
2605 else {
2606 target = "target=\"" + HtmlUtil.escapeAttribute(target) + "\"";
2607 }
2608
2609 return target;
2610 }
2611
2612 public String getLayoutURL(Layout layout, ThemeDisplay themeDisplay)
2613 throws PortalException, SystemException {
2614
2615 return getLayoutURL(layout, themeDisplay, true);
2616 }
2617
2618 public String getLayoutURL(
2619 Layout layout, ThemeDisplay themeDisplay, boolean doAsUser)
2620 throws PortalException, SystemException {
2621
2622 if (layout == null) {
2623 return themeDisplay.getPathMain() + PATH_PORTAL_LAYOUT;
2624 }
2625
2626 if (!layout.isTypeURL()) {
2627 String layoutFriendlyURL = getLayoutFriendlyURL(
2628 layout, themeDisplay);
2629
2630 if (Validator.isNotNull(layoutFriendlyURL)) {
2631 layoutFriendlyURL = addPreservedParameters(
2632 themeDisplay, layout, layoutFriendlyURL, doAsUser);
2633
2634 return layoutFriendlyURL;
2635 }
2636 }
2637
2638 String layoutURL = getLayoutActualURL(layout);
2639
2640 layoutURL = addPreservedParameters(
2641 themeDisplay, layout, layoutURL, doAsUser);
2642
2643 return layoutURL;
2644 }
2645
2646 public String getLayoutURL(ThemeDisplay themeDisplay)
2647 throws PortalException, SystemException {
2648
2649 return getLayoutURL(themeDisplay.getLayout(), themeDisplay);
2650 }
2651
2652 public String getLayoutViewPage(Layout layout) {
2653 LayoutSettings layoutSettings = LayoutSettings.getInstance(
2654 layout.getType());
2655
2656 return layoutSettings.getViewPage();
2657 }
2658
2659 public String getLayoutViewPage(String type) {
2660 LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
2661
2662 return layoutSettings.getViewPage();
2663 }
2664
2665 public LiferayPortletRequest getLiferayPortletRequest(
2666 PortletRequest portletRequest) {
2667
2668 PortletRequestImpl portletRequestImpl =
2669 PortletRequestImpl.getPortletRequestImpl(portletRequest);
2670
2671 return portletRequestImpl;
2672 }
2673
2674 public LiferayPortletResponse getLiferayPortletResponse(
2675 PortletResponse portletResponse) {
2676
2677 PortletResponseImpl portletResponseImpl =
2678 PortletResponseImpl.getPortletResponseImpl(portletResponse);
2679
2680 return portletResponseImpl;
2681 }
2682
2683 public Locale getLocale(HttpServletRequest request) {
2684 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
2685 WebKeys.THEME_DISPLAY);
2686
2687 if (themeDisplay != null) {
2688 return themeDisplay.getLocale();
2689 }
2690 else {
2691 HttpSession session = request.getSession();
2692
2693 return (Locale)session.getAttribute(Globals.LOCALE_KEY);
2694 }
2695 }
2696
2697 public Locale getLocale(RenderRequest renderRequest) {
2698 return getLocale(getHttpServletRequest(renderRequest));
2699 }
2700
2701 public String getMailId(String mx, String popPortletPrefix, Object... ids) {
2702 StringBundler sb = new StringBundler(ids.length * 2 + 7);
2703
2704 sb.append(StringPool.LESS_THAN);
2705 sb.append(popPortletPrefix);
2706
2707 if (!popPortletPrefix.endsWith(StringPool.PERIOD)) {
2708 sb.append(StringPool.PERIOD);
2709 }
2710
2711 for (int i = 0; i < ids.length; i++) {
2712 Object id = ids[i];
2713
2714 if (i != 0) {
2715 sb.append(StringPool.PERIOD);
2716 }
2717
2718 sb.append(id);
2719 }
2720
2721 sb.append(StringPool.AT);
2722
2723 if (Validator.isNotNull(PropsValues.POP_SERVER_SUBDOMAIN)) {
2724 sb.append(PropsValues.POP_SERVER_SUBDOMAIN);
2725 sb.append(StringPool.PERIOD);
2726 }
2727
2728 sb.append(mx);
2729 sb.append(StringPool.GREATER_THAN);
2730
2731 return sb.toString();
2732 }
2733
2734 public String getNetvibesURL(Portlet portlet, ThemeDisplay themeDisplay)
2735 throws PortalException, SystemException {
2736
2737 return getServletURL(
2738 portlet, PropsValues.NETVIBES_SERVLET_MAPPING, themeDisplay);
2739 }
2740
2741 public String getNewPortletTitle(
2742 String portletTitle, String oldScopeName, String newScopeName) {
2743
2744 if (portletTitle.endsWith(" (" + oldScopeName + ")")) {
2745 int pos = portletTitle.lastIndexOf(" (" + oldScopeName + ")");
2746
2747 portletTitle = portletTitle.substring(0, pos);
2748 }
2749
2750 if (Validator.isNull(newScopeName)) {
2751 return portletTitle;
2752 }
2753
2754 StringBundler sb = new StringBundler(5);
2755
2756 sb.append(portletTitle);
2757 sb.append(StringPool.SPACE);
2758 sb.append(StringPool.OPEN_PARENTHESIS);
2759 sb.append(newScopeName);
2760 sb.append(StringPool.CLOSE_PARENTHESIS);
2761
2762 return sb.toString();
2763 }
2764
2765 public HttpServletRequest getOriginalServletRequest(
2766 HttpServletRequest request) {
2767
2768 List<PersistentHttpServletRequestWrapper>
2769 persistentHttpServletRequestWrappers =
2770 new ArrayList<PersistentHttpServletRequestWrapper>();
2771
2772 HttpServletRequest originalRequest = request;
2773
2774 while (originalRequest.getClass().getName().startsWith(
2775 "com.liferay.")) {
2776
2777 if (originalRequest instanceof
2778 PersistentHttpServletRequestWrapper) {
2779
2780 PersistentHttpServletRequestWrapper
2781 persistentHttpServletRequestWrapper =
2782 (PersistentHttpServletRequestWrapper)originalRequest;
2783
2784 persistentHttpServletRequestWrappers.add(
2785 persistentHttpServletRequestWrapper.clone());
2786 }
2787
2788
2789
2790
2791 HttpServletRequestWrapper httpServletRequestWrapper =
2792 (HttpServletRequestWrapper)originalRequest;
2793
2794 originalRequest =
2795 (HttpServletRequest)httpServletRequestWrapper.getRequest();
2796 }
2797
2798 for (int i = persistentHttpServletRequestWrappers.size() - 1; i >= 0;
2799 i--) {
2800
2801 HttpServletRequestWrapper httpServletRequestWrapper =
2802 persistentHttpServletRequestWrappers.get(i);
2803
2804 httpServletRequestWrapper.setRequest(originalRequest);
2805
2806 originalRequest = httpServletRequestWrapper;
2807 }
2808
2809 return originalRequest;
2810 }
2811
2812 public long getParentGroupId(long groupId)
2813 throws PortalException, SystemException {
2814
2815 if (groupId <= 0) {
2816 return 0;
2817 }
2818
2819 Group group = GroupLocalServiceUtil.getGroup(groupId);
2820
2821 long parentGroupId = groupId;
2822
2823 if (group.isLayout()) {
2824 parentGroupId = group.getParentGroupId();
2825 }
2826
2827 return parentGroupId;
2828 }
2829
2830 public String getPathContext() {
2831 return _pathContext;
2832 }
2833
2834 public String getPathFriendlyURLPrivateGroup() {
2835 return _pathFriendlyURLPrivateGroup;
2836 }
2837
2838 public String getPathFriendlyURLPrivateUser() {
2839 return _pathFriendlyURLPrivateUser;
2840 }
2841
2842 public String getPathFriendlyURLPublic() {
2843 return _pathFriendlyURLPublic;
2844 }
2845
2846 public String getPathImage() {
2847 return _pathImage;
2848 }
2849
2850 public String getPathMain() {
2851 return _pathMain;
2852 }
2853
2854 public String getPathProxy() {
2855 return _pathProxy;
2856 }
2857
2858 public long getPlidFromFriendlyURL(long companyId, String friendlyURL) {
2859 if (Validator.isNull(friendlyURL)) {
2860 return LayoutConstants.DEFAULT_PLID;
2861 }
2862
2863 String[] urlParts = friendlyURL.split("\\/", 4);
2864
2865 if ((friendlyURL.charAt(0) != CharPool.SLASH) &&
2866 (urlParts.length != 4)) {
2867
2868 return LayoutConstants.DEFAULT_PLID;
2869 }
2870
2871 boolean privateLayout = true;
2872
2873 String urlPrefix = StringPool.SLASH + urlParts[1];
2874
2875 if (_PUBLIC_GROUP_SERVLET_MAPPING.equals(urlPrefix)) {
2876 privateLayout = false;
2877 }
2878 else if (_PRIVATE_GROUP_SERVLET_MAPPING.equals(urlPrefix) ||
2879 _PRIVATE_USER_SERVLET_MAPPING.equals(urlPrefix)) {
2880
2881 privateLayout = true;
2882 }
2883 else {
2884 return LayoutConstants.DEFAULT_PLID;
2885 }
2886
2887 Group group = null;
2888
2889 try {
2890 group = GroupLocalServiceUtil.getFriendlyURLGroup(
2891 companyId, StringPool.SLASH + urlParts[2]);
2892 }
2893 catch (Exception e) {
2894 }
2895
2896 if (group != null) {
2897 Layout layout = null;
2898
2899 try {
2900 String layoutFriendlyURL = null;
2901
2902 if (urlParts.length == 4) {
2903 layoutFriendlyURL = StringPool.SLASH + urlParts[3];
2904
2905 layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
2906 group.getGroupId(), privateLayout, layoutFriendlyURL);
2907 }
2908 else {
2909 List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
2910 group.getGroupId(), privateLayout,
2911 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID, true, 0, 1);
2912
2913 if (!layouts.isEmpty()) {
2914 layout = layouts.get(0);
2915 }
2916 else {
2917 return LayoutConstants.DEFAULT_PLID;
2918 }
2919 }
2920
2921 return layout.getPlid();
2922 }
2923 catch (Exception e) {
2924 }
2925 }
2926
2927 return LayoutConstants.DEFAULT_PLID;
2928 }
2929
2930 public long getPlidFromPortletId(
2931 long groupId, boolean privateLayout, String portletId)
2932 throws PortalException, SystemException {
2933
2934 long plid = LayoutConstants.DEFAULT_PLID;
2935
2936 StringBundler sb = new StringBundler(5);
2937
2938 sb.append(groupId);
2939 sb.append(StringPool.SPACE);
2940 sb.append(privateLayout);
2941 sb.append(StringPool.SPACE);
2942 sb.append(portletId);
2943
2944 String key = sb.toString();
2945
2946 Long plidObj = _plidToPortletIdMap.get(key);
2947
2948 if (plidObj == null) {
2949 plid = doGetPlidFromPortletId(groupId, privateLayout, portletId);
2950
2951 if (plid != LayoutConstants.DEFAULT_PLID) {
2952 _plidToPortletIdMap.put(key, plid);
2953 }
2954 }
2955 else {
2956 plid = plidObj.longValue();
2957
2958 boolean validPlid = false;
2959
2960 try {
2961 Layout layout = LayoutLocalServiceUtil.getLayout(plid);
2962
2963 LayoutTypePortlet layoutTypePortlet =
2964 (LayoutTypePortlet)layout.getLayoutType();
2965
2966 if (layoutTypePortlet.hasDefaultScopePortletId(
2967 groupId, portletId)) {
2968
2969 validPlid = true;
2970 }
2971 }
2972 catch (Exception e) {
2973 }
2974
2975 if (!validPlid) {
2976 _plidToPortletIdMap.remove(key);
2977
2978 plid = doGetPlidFromPortletId(
2979 groupId, privateLayout, portletId);
2980
2981 if (plid != LayoutConstants.DEFAULT_PLID) {
2982 _plidToPortletIdMap.put(key, plid);
2983 }
2984 }
2985 }
2986
2987 return plid;
2988 }
2989
2990 public long getPlidFromPortletId(long groupId, String portletId)
2991 throws PortalException, SystemException {
2992
2993 long plid = getPlidFromPortletId(groupId, false, portletId);
2994
2995 if (plid == LayoutConstants.DEFAULT_PLID) {
2996 plid = getPlidFromPortletId(groupId, true, portletId);
2997 }
2998
2999 if (plid == LayoutConstants.DEFAULT_PLID) {
3000 if (_log.isDebugEnabled()) {
3001 _log.debug(
3002 "Portlet " + portletId +
3003 " does not exist on a page in group " + groupId);
3004 }
3005 }
3006
3007 return plid;
3008 }
3009
3010 public String getPortalLibDir() {
3011 return PropsValues.LIFERAY_LIB_PORTAL_DIR;
3012 }
3013
3014
3017 public int getPortalPort() {
3018 return _portalPort.get();
3019 }
3020
3021 public int getPortalPort(boolean secure) {
3022 if (secure) {
3023 return _securePortalPort.get();
3024 }
3025 else {
3026 return _portalPort.get();
3027 }
3028 }
3029
3030 public Properties getPortalProperties() {
3031 return PropsUtil.getProperties();
3032 }
3033
3034 public String getPortalURL(HttpServletRequest request) {
3035 return getPortalURL(request, isSecure(request));
3036 }
3037
3038 public String getPortalURL(HttpServletRequest request, boolean secure) {
3039 return getPortalURL(
3040 request.getServerName(), request.getServerPort(), secure);
3041 }
3042
3043 public String getPortalURL(Layout layout, ThemeDisplay themeDisplay)
3044 throws PortalException, SystemException {
3045
3046 String serverName = themeDisplay.getServerName();
3047
3048 if (layout == null) {
3049 layout = themeDisplay.getLayout();
3050 }
3051
3052 if (layout != null) {
3053 LayoutSet layoutSet = layout.getLayoutSet();
3054
3055 String virtualHostname = layoutSet.getVirtualHostname();
3056
3057 if (Validator.isNotNull(virtualHostname)) {
3058 serverName = virtualHostname;
3059 }
3060 }
3061
3062 return getPortalURL(
3063 serverName, themeDisplay.getServerPort(), themeDisplay.isSecure());
3064 }
3065
3066 public String getPortalURL(PortletRequest portletRequest) {
3067 return getPortalURL(portletRequest, portletRequest.isSecure());
3068 }
3069
3070 public String getPortalURL(PortletRequest portletRequest, boolean secure) {
3071 return getPortalURL(
3072 portletRequest.getServerName(), portletRequest.getServerPort(),
3073 secure);
3074 }
3075
3076 public String getPortalURL(
3077 String serverName, int serverPort, boolean secure) {
3078
3079 StringBundler sb = new StringBundler();
3080
3081 if (secure || Http.HTTPS.equals(PropsValues.WEB_SERVER_PROTOCOL)) {
3082 sb.append(Http.HTTPS_WITH_SLASH);
3083 }
3084 else {
3085 sb.append(Http.HTTP_WITH_SLASH);
3086 }
3087
3088 if (Validator.isNull(PropsValues.WEB_SERVER_HOST)) {
3089 sb.append(serverName);
3090 }
3091 else {
3092 sb.append(PropsValues.WEB_SERVER_HOST);
3093 }
3094
3095 if (!secure) {
3096 if (PropsValues.WEB_SERVER_HTTP_PORT == -1) {
3097 if ((serverPort != Http.HTTP_PORT) &&
3098 (serverPort != Http.HTTPS_PORT)) {
3099
3100 sb.append(StringPool.COLON);
3101 sb.append(serverPort);
3102 }
3103 }
3104 else {
3105 if (PropsValues.WEB_SERVER_HTTP_PORT != Http.HTTP_PORT) {
3106 sb.append(StringPool.COLON);
3107 sb.append(PropsValues.WEB_SERVER_HTTP_PORT);
3108 }
3109 }
3110 }
3111
3112 if (secure) {
3113 if (PropsValues.WEB_SERVER_HTTPS_PORT == -1) {
3114 if ((serverPort != Http.HTTP_PORT) &&
3115 (serverPort != Http.HTTPS_PORT)) {
3116
3117 sb.append(StringPool.COLON);
3118 sb.append(serverPort);
3119 }
3120 }
3121 else {
3122 if (PropsValues.WEB_SERVER_HTTPS_PORT != Http.HTTPS_PORT) {
3123 sb.append(StringPool.COLON);
3124 sb.append(PropsValues.WEB_SERVER_HTTPS_PORT);
3125 }
3126 }
3127 }
3128
3129 return sb.toString();
3130 }
3131
3132 public String getPortalURL(ThemeDisplay themeDisplay)
3133 throws PortalException, SystemException {
3134
3135 return getPortalURL(null, themeDisplay);
3136 }
3137
3138 public String getPortalWebDir() {
3139 return PropsValues.LIFERAY_WEB_PORTAL_DIR;
3140 }
3141
3142 public Set<String> getPortletAddDefaultResourceCheckWhitelist() {
3143 return _portletAddDefaultResourceCheckWhitelist;
3144 }
3145
3146 public Set<String> getPortletAddDefaultResourceCheckWhitelistActions() {
3147 return _portletAddDefaultResourceCheckWhitelistActions;
3148 }
3149
3150
3153 public List<BreadcrumbEntry> getPortletBreadcrumbList(
3154 HttpServletRequest request) {
3155
3156 return getPortletBreadcrumbs(request);
3157 }
3158
3159 public List<BreadcrumbEntry> getPortletBreadcrumbs(
3160 HttpServletRequest request) {
3161
3162 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
3163 WebKeys.THEME_DISPLAY);
3164
3165 PortletDisplay portletDisplay = themeDisplay.getPortletDisplay();
3166
3167 String name = WebKeys.PORTLET_BREADCRUMBS;
3168
3169 if (Validator.isNotNull(portletDisplay.getId()) &&
3170 !portletDisplay.isFocused()) {
3171
3172 name += StringPool.UNDERLINE + portletDisplay.getId();
3173 }
3174
3175 return (List<BreadcrumbEntry>)request.getAttribute(name);
3176 }
3177
3178 public String getPortletDescription(
3179 Portlet portlet, ServletContext servletContext, Locale locale) {
3180
3181 PortletConfig portletConfig = PortletConfigFactoryUtil.create(
3182 portlet, servletContext);
3183
3184 ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
3185
3186 String portletDescription = ResourceBundleUtil.getString(
3187 resourceBundle,
3188 JavaConstants.JAVAX_PORTLET_DESCRIPTION.concat(
3189 StringPool.PERIOD).concat(portlet.getRootPortletId()));
3190
3191 if (Validator.isNull(portletDescription)) {
3192 portletDescription = ResourceBundleUtil.getString(
3193 resourceBundle, JavaConstants.JAVAX_PORTLET_DESCRIPTION);
3194 }
3195
3196 return portletDescription;
3197 }
3198
3199 public String getPortletDescription(Portlet portlet, User user) {
3200 return getPortletDescription(portlet.getPortletId(), user);
3201 }
3202
3203 public String getPortletDescription(String portletId, Locale locale) {
3204 return LanguageUtil.get(
3205 locale,
3206 JavaConstants.JAVAX_PORTLET_DESCRIPTION.concat(
3207 StringPool.PERIOD).concat(portletId));
3208 }
3209
3210 public String getPortletDescription(String portletId, String languageId) {
3211 Locale locale = LocaleUtil.fromLanguageId(languageId);
3212
3213 return getPortletDescription(portletId, locale);
3214 }
3215
3216 public String getPortletDescription(String portletId, User user) {
3217 return LanguageUtil.get(
3218 user.getLocale(),
3219 JavaConstants.JAVAX_PORTLET_DESCRIPTION.concat(
3220 StringPool.PERIOD).concat(portletId));
3221 }
3222
3223 public Object[] getPortletFriendlyURLMapper(
3224 long groupId, boolean privateLayout, String url,
3225 Map<String, String[]> params, Map<String, Object> requestContext)
3226 throws PortalException, SystemException {
3227
3228 boolean foundFriendlyURLMapper = false;
3229
3230 String friendlyURL = url;
3231 String queryString = StringPool.BLANK;
3232
3233 List<Portlet> portlets =
3234 PortletLocalServiceUtil.getFriendlyURLMapperPortlets();
3235
3236 for (Portlet portlet : portlets) {
3237 FriendlyURLMapper friendlyURLMapper =
3238 portlet.getFriendlyURLMapperInstance();
3239
3240 if (url.endsWith(
3241 StringPool.SLASH + friendlyURLMapper.getMapping())) {
3242
3243 url += StringPool.SLASH;
3244 }
3245
3246 int pos = -1;
3247
3248 if (friendlyURLMapper.isCheckMappingWithPrefix()) {
3249 pos = url.indexOf(
3250 FRIENDLY_URL_SEPARATOR + friendlyURLMapper.getMapping() +
3251 StringPool.SLASH);
3252 }
3253 else {
3254 pos = url.indexOf(
3255 StringPool.SLASH + friendlyURLMapper.getMapping() +
3256 StringPool.SLASH);
3257 }
3258
3259 if (pos != -1) {
3260 foundFriendlyURLMapper = true;
3261
3262 friendlyURL = url.substring(0, pos);
3263
3264 InheritableMap<String, String[]> actualParams =
3265 new InheritableMap<String, String[]>();
3266
3267 if (params != null) {
3268 actualParams.setParentMap(params);
3269 }
3270
3271 Map<String, String> prpIdentifiers =
3272 new HashMap<String, String>();
3273
3274 Set<PublicRenderParameter> publicRenderParameters =
3275 portlet.getPublicRenderParameters();
3276
3277 for (PublicRenderParameter publicRenderParameter :
3278 publicRenderParameters) {
3279
3280 QName qName = publicRenderParameter.getQName();
3281
3282 String publicRenderParameterIdentifier =
3283 qName.getLocalPart();
3284 String publicRenderParameterName =
3285 PortletQNameUtil.getPublicRenderParameterName(qName);
3286
3287 prpIdentifiers.put(
3288 publicRenderParameterIdentifier,
3289 publicRenderParameterName);
3290 }
3291
3292 FriendlyURLMapperThreadLocal.setPRPIdentifiers(prpIdentifiers);
3293
3294 if (friendlyURLMapper.isCheckMappingWithPrefix()) {
3295 friendlyURLMapper.populateParams(
3296 url.substring(pos + 2), actualParams, requestContext);
3297 }
3298 else {
3299 friendlyURLMapper.populateParams(
3300 url.substring(pos), actualParams, requestContext);
3301 }
3302
3303 queryString =
3304 StringPool.AMPERSAND +
3305 HttpUtil.parameterMapToString(actualParams, false);
3306
3307 break;
3308 }
3309 }
3310
3311 if (!foundFriendlyURLMapper) {
3312 int x = url.indexOf(FRIENDLY_URL_SEPARATOR);
3313
3314 if (x != -1) {
3315 int y = url.indexOf(CharPool.SLASH, x + 3);
3316
3317 if (y == -1) {
3318 y = url.length();
3319 }
3320
3321 String ppid = url.substring(x + 3, y);
3322
3323 if (Validator.isNotNull(ppid)) {
3324 friendlyURL = url.substring(0, x);
3325
3326 Map<String, String[]> actualParams = null;
3327
3328 if (params != null) {
3329 actualParams = new HashMap<String, String[]>(params);
3330 }
3331 else {
3332 actualParams = new HashMap<String, String[]>();
3333 }
3334
3335 actualParams.put("p_p_id", new String[] {ppid});
3336 actualParams.put("p_p_lifecycle", new String[] {"0"});
3337 actualParams.put(
3338 "p_p_state",
3339 new String[] {WindowState.MAXIMIZED.toString()});
3340 actualParams.put(
3341 "p_p_mode", new String[] {PortletMode.VIEW.toString()});
3342
3343 queryString =
3344 StringPool.AMPERSAND +
3345 HttpUtil.parameterMapToString(actualParams, false);
3346 }
3347 }
3348 }
3349
3350 friendlyURL = StringUtil.replace(
3351 friendlyURL, StringPool.DOUBLE_SLASH, StringPool.SLASH);
3352
3353 if (friendlyURL.endsWith(StringPool.SLASH)) {
3354 friendlyURL = friendlyURL.substring(0, friendlyURL.length() - 1);
3355 }
3356
3357 Layout layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
3358 groupId, privateLayout, friendlyURL);
3359
3360 return new Object[] {layout, queryString};
3361 }
3362
3363 public String getPortletId(HttpServletRequest request) {
3364 PortletConfigImpl portletConfigImpl =
3365 (PortletConfigImpl)request.getAttribute(
3366 JavaConstants.JAVAX_PORTLET_CONFIG);
3367
3368 if (portletConfigImpl != null) {
3369 return portletConfigImpl.getPortletId();
3370 }
3371 else {
3372 return null;
3373 }
3374 }
3375
3376 public String getPortletId(PortletRequest portletRequest) {
3377 PortletConfigImpl portletConfigImpl =
3378 (PortletConfigImpl)portletRequest.getAttribute(
3379 JavaConstants.JAVAX_PORTLET_CONFIG);
3380
3381 if (portletConfigImpl != null) {
3382 return portletConfigImpl.getPortletId();
3383 }
3384 else {
3385 return null;
3386 }
3387 }
3388
3389 public String getPortletLongTitle(Portlet portlet, Locale locale) {
3390 return getPortletLongTitle(portlet.getPortletId(), locale);
3391 }
3392
3393 public String getPortletLongTitle(
3394 Portlet portlet, ServletContext servletContext, Locale locale) {
3395
3396 PortletConfig portletConfig = PortletConfigFactoryUtil.create(
3397 portlet, servletContext);
3398
3399 ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
3400
3401 try {
3402 String portletLongTitle = resourceBundle.getString(
3403 JavaConstants.JAVAX_PORTLET_LONG_TITLE);
3404
3405 if (portletLongTitle.startsWith(
3406 JavaConstants.JAVAX_PORTLET_LONG_TITLE)) {
3407
3408 portletLongTitle = getPortletTitle(
3409 portlet, servletContext, locale);
3410 }
3411
3412 return portletLongTitle;
3413 }
3414 catch (Exception e) {
3415 return getPortletTitle(portlet, servletContext, locale);
3416 }
3417 }
3418
3419 public String getPortletLongTitle(Portlet portlet, String languageId) {
3420 return getPortletLongTitle(portlet.getPortletId(), languageId);
3421 }
3422
3423 public String getPortletLongTitle(Portlet portlet, User user) {
3424 return getPortletLongTitle(portlet.getPortletId(), user);
3425 }
3426
3427 public String getPortletLongTitle(String portletId, Locale locale) {
3428 String portletLongTitle = LanguageUtil.get(
3429 locale,
3430 JavaConstants.JAVAX_PORTLET_LONG_TITLE.concat(
3431 StringPool.PERIOD).concat(portletId),
3432 StringPool.BLANK);
3433
3434 if (Validator.isNull(portletLongTitle)) {
3435 portletLongTitle = getPortletTitle(portletId, locale);
3436 }
3437
3438 return portletLongTitle;
3439 }
3440
3441 public String getPortletLongTitle(String portletId, String languageId) {
3442 Locale locale = LocaleUtil.fromLanguageId(languageId);
3443
3444 return getPortletLongTitle(portletId, locale);
3445 }
3446
3447 public String getPortletLongTitle(String portletId, User user) {
3448 return getPortletLongTitle(portletId, user.getLocale());
3449 }
3450
3451 public String getPortletNamespace(String portletId) {
3452 return StringPool.UNDERLINE.concat(portletId).concat(
3453 StringPool.UNDERLINE);
3454 }
3455
3456 public String getPortletTitle(Portlet portlet, Locale locale) {
3457 return getPortletTitle(portlet.getPortletId(), locale);
3458 }
3459
3460 public String getPortletTitle(
3461 Portlet portlet, ServletContext servletContext, Locale locale) {
3462
3463 PortletConfig portletConfig = PortletConfigFactoryUtil.create(
3464 portlet, servletContext);
3465
3466 ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
3467
3468 String portletTitle = ResourceBundleUtil.getString(
3469 resourceBundle,
3470 JavaConstants.JAVAX_PORTLET_TITLE.concat(StringPool.PERIOD).concat(
3471 portlet.getRootPortletId()));
3472
3473 if (Validator.isNull(portletTitle)) {
3474 portletTitle = ResourceBundleUtil.getString(
3475 resourceBundle, JavaConstants.JAVAX_PORTLET_TITLE);
3476 }
3477
3478 return portletTitle;
3479 }
3480
3481 public String getPortletTitle(Portlet portlet, String languageId) {
3482 return getPortletTitle(portlet.getPortletId(), languageId);
3483 }
3484
3485 public String getPortletTitle(Portlet portlet, User user) {
3486 return getPortletTitle(portlet.getPortletId(), user);
3487 }
3488
3489 public String getPortletTitle(RenderRequest renderRequest) {
3490 String portletId = (String)renderRequest.getAttribute(
3491 WebKeys.PORTLET_ID);
3492
3493 Portlet portlet = PortletLocalServiceUtil.getPortletById(portletId);
3494
3495 HttpServletRequest request = PortalUtil.getHttpServletRequest(
3496 renderRequest);
3497
3498 ServletContext servletContext = (ServletContext)request.getAttribute(
3499 WebKeys.CTX);
3500
3501 Locale locale = renderRequest.getLocale();
3502
3503 return getPortletTitle(portlet, servletContext, locale);
3504 }
3505
3506 public String getPortletTitle(RenderResponse renderResponse) {
3507 PortletResponseImpl portletResponseImpl =
3508 PortletResponseImpl.getPortletResponseImpl(renderResponse);
3509
3510 return ((RenderResponseImpl)portletResponseImpl).getTitle();
3511 }
3512
3513 public String getPortletTitle(String portletId, Locale locale) {
3514 return LanguageUtil.get(
3515 locale,
3516 JavaConstants.JAVAX_PORTLET_TITLE.concat(StringPool.PERIOD).concat(
3517 portletId));
3518 }
3519
3520 public String getPortletTitle(String portletId, String languageId) {
3521 Locale locale = LocaleUtil.fromLanguageId(languageId);
3522
3523 return getPortletTitle(portletId, locale);
3524 }
3525
3526 public String getPortletTitle(String portletId, User user) {
3527 return LanguageUtil.get(
3528 user.getLocale(),
3529 JavaConstants.JAVAX_PORTLET_TITLE.concat(StringPool.PERIOD).concat(
3530 portletId));
3531 }
3532
3533 public String getPortletXmlFileName() throws SystemException {
3534 if (PrefsPropsUtil.getBoolean(
3535 PropsKeys.AUTO_DEPLOY_CUSTOM_PORTLET_XML,
3536 PropsValues.AUTO_DEPLOY_CUSTOM_PORTLET_XML)) {
3537
3538 return PORTLET_XML_FILE_NAME_CUSTOM;
3539 }
3540 else {
3541 return PORTLET_XML_FILE_NAME_STANDARD;
3542 }
3543 }
3544
3545 public PortletPreferences getPreferences(HttpServletRequest request) {
3546 RenderRequest renderRequest = (RenderRequest)request.getAttribute(
3547 JavaConstants.JAVAX_PORTLET_REQUEST);
3548
3549 PortletPreferences portletPreferences = null;
3550
3551 if (renderRequest != null) {
3552 PortletPreferencesWrapper portletPreferencesWrapper =
3553 (PortletPreferencesWrapper)renderRequest.getPreferences();
3554
3555 portletPreferences =
3556 portletPreferencesWrapper.getPortletPreferencesImpl();
3557 }
3558
3559 return portletPreferences;
3560 }
3561
3562 public PreferencesValidator getPreferencesValidator(Portlet portlet) {
3563 PortletBag portletBag = PortletBagPool.get(portlet.getRootPortletId());
3564
3565 return portletBag.getPreferencesValidatorInstance();
3566 }
3567
3568 public String getRelativeHomeURL(HttpServletRequest request)
3569 throws PortalException, SystemException {
3570
3571 Company company = getCompany(request);
3572
3573 String homeURL = company.getHomeURL();
3574
3575 if (Validator.isNull(homeURL)) {
3576 homeURL = PropsValues.COMPANY_DEFAULT_HOME_URL;
3577 }
3578
3579 return homeURL;
3580 }
3581
3582 public long getScopeGroupId(HttpServletRequest request)
3583 throws PortalException, SystemException {
3584
3585 String portletId = getPortletId(request);
3586
3587 return getScopeGroupId(request, portletId);
3588 }
3589
3590 public long getScopeGroupId(HttpServletRequest request, String portletId)
3591 throws PortalException, SystemException {
3592
3593 return getScopeGroupId(request, portletId, false);
3594 }
3595
3596 public long getScopeGroupId(
3597 HttpServletRequest request, String portletId,
3598 boolean checkStagingGroup)
3599 throws PortalException, SystemException {
3600
3601 Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
3602
3603 long scopeGroupId = 0;
3604
3605 if (layout != null) {
3606 Group group = layout.getGroup();
3607
3608 if (group.isControlPanel()) {
3609 long doAsGroupId = ParamUtil.getLong(request, "doAsGroupId");
3610
3611 Group doAsGroup = GroupLocalServiceUtil.fetchGroup(doAsGroupId);
3612
3613 if ((doAsGroupId <= 0) || (doAsGroup == null)) {
3614 doAsGroupId = getDefaultScopeGroupId(group.getCompanyId());
3615 }
3616
3617 if (doAsGroupId > 0) {
3618 scopeGroupId = doAsGroupId;
3619 }
3620
3621 group = GroupLocalServiceUtil.fetchGroup(scopeGroupId);
3622
3623 if ((group != null) && group.hasStagingGroup()) {
3624 try {
3625 Group stagingGroup = group.getStagingGroup();
3626
3627 scopeGroupId = stagingGroup.getGroupId();
3628 }
3629 catch (Exception e) {
3630 }
3631 }
3632 }
3633
3634 if ((portletId != null) &&
3635 (group.isStaged() || group.isStagingGroup())) {
3636
3637 Group liveGroup = group;
3638
3639 if (group.isStagingGroup()) {
3640 liveGroup = group.getLiveGroup();
3641 }
3642
3643 if (liveGroup.isStaged() &&
3644 !liveGroup.isStagedPortlet(portletId)) {
3645
3646 Layout liveGroupLayout =
3647 LayoutLocalServiceUtil.fetchLayoutByUuidAndGroupId(
3648 layout.getUuid(), liveGroup.getGroupId());
3649
3650 if ((liveGroupLayout != null) &&
3651 liveGroupLayout.hasScopeGroup()) {
3652
3653 scopeGroupId = getScopeGroupId(
3654 liveGroupLayout, portletId);
3655 }
3656 else if (checkStagingGroup &&
3657 !liveGroup.isStagedRemotely()) {
3658
3659 Group stagingGroup = liveGroup.getStagingGroup();
3660
3661 scopeGroupId = stagingGroup.getGroupId();
3662 }
3663 else {
3664 scopeGroupId = liveGroup.getGroupId();
3665 }
3666 }
3667 }
3668 }
3669
3670 if (scopeGroupId <= 0) {
3671 scopeGroupId = getScopeGroupId(layout, portletId);
3672 }
3673
3674 return scopeGroupId;
3675 }
3676
3677 public long getScopeGroupId(Layout layout) {
3678 if (layout == null) {
3679 return 0;
3680 }
3681 else {
3682 return layout.getGroupId();
3683 }
3684 }
3685
3686 public long getScopeGroupId(Layout layout, String portletId) {
3687 if (layout == null) {
3688 return 0;
3689 }
3690
3691 if (Validator.isNull(portletId)) {
3692 return layout.getGroupId();
3693 }
3694
3695 try {
3696 PortletPreferences portletSetup =
3697 PortletPreferencesFactoryUtil.getStrictLayoutPortletSetup(
3698 layout, portletId);
3699
3700 String scopeType = GetterUtil.getString(
3701 portletSetup.getValue("lfrScopeType", null));
3702
3703 if (Validator.isNull(scopeType)) {
3704 return layout.getGroupId();
3705 }
3706
3707 if (scopeType.equals("company")) {
3708 Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
3709 layout.getCompanyId());
3710
3711 return companyGroup.getGroupId();
3712 }
3713 else {
3714 String scopeLayoutUuid = GetterUtil.getString(
3715 portletSetup.getValue("lfrScopeLayoutUuid", null));
3716
3717 Layout scopeLayout =
3718 LayoutLocalServiceUtil.getLayoutByUuidAndGroupId(
3719 scopeLayoutUuid, layout.getGroupId());
3720
3721 Group scopeGroup = scopeLayout.getScopeGroup();
3722
3723 return scopeGroup.getGroupId();
3724 }
3725 }
3726 catch (Exception e) {
3727 return layout.getGroupId();
3728 }
3729 }
3730
3731 public long getScopeGroupId(long plid) {
3732 Layout layout = null;
3733
3734 try {
3735 layout = LayoutLocalServiceUtil.getLayout(plid);
3736 }
3737 catch (Exception e) {
3738 }
3739
3740 return getScopeGroupId(layout);
3741 }
3742
3743 public long getScopeGroupId(PortletRequest portletRequest)
3744 throws PortalException, SystemException {
3745
3746 return getScopeGroupId(getHttpServletRequest(portletRequest));
3747 }
3748
3749 public User getSelectedUser(HttpServletRequest request)
3750 throws PortalException, SystemException {
3751
3752 return getSelectedUser(request, true);
3753 }
3754
3755 public User getSelectedUser(
3756 HttpServletRequest request, boolean checkPermission)
3757 throws PortalException, SystemException {
3758
3759 long userId = ParamUtil.getLong(request, "p_u_i_d");
3760
3761 User user = null;
3762
3763 try {
3764 if (checkPermission) {
3765 user = UserServiceUtil.getUserById(userId);
3766 }
3767 else {
3768 user = UserLocalServiceUtil.getUserById(userId);
3769 }
3770 }
3771 catch (NoSuchUserException nsue) {
3772 }
3773
3774 return user;
3775 }
3776
3777 public User getSelectedUser(PortletRequest portletRequest)
3778 throws PortalException, SystemException {
3779
3780 return getSelectedUser(portletRequest, true);
3781 }
3782
3783 public User getSelectedUser(
3784 PortletRequest portletRequest, boolean checkPermission)
3785 throws PortalException, SystemException {
3786
3787 return getSelectedUser(
3788 getHttpServletRequest(portletRequest), checkPermission);
3789 }
3790
3791 public long[] getSiteAndCompanyGroupIds(long groupId)
3792 throws PortalException, SystemException {
3793
3794 Group scopeGroup = GroupLocalServiceUtil.getGroup(groupId);
3795
3796 Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
3797 scopeGroup.getCompanyId());
3798
3799 if (scopeGroup.isLayout()) {
3800 return new long[] {
3801 scopeGroup.getParentGroupId(), companyGroup.getGroupId()
3802 };
3803 }
3804 else if (scopeGroup.isRegularSite()) {
3805 return new long[] {groupId, companyGroup.getGroupId()};
3806 }
3807 else {
3808 return new long[] {companyGroup.getGroupId()};
3809 }
3810 }
3811
3812 public long[] getSiteAndCompanyGroupIds(ThemeDisplay themeDisplay)
3813 throws PortalException, SystemException {
3814
3815 return getSiteAndCompanyGroupIds(themeDisplay.getScopeGroupId());
3816 }
3817
3818 public String getSiteLoginURL(ThemeDisplay themeDisplay)
3819 throws PortalException, SystemException {
3820
3821 if (Validator.isNull(PropsValues.AUTH_LOGIN_SITE_URL)) {
3822 return null;
3823 }
3824
3825 List<Layout> layouts = themeDisplay.getUnfilteredLayouts();
3826
3827 if (layouts == null) {
3828 return null;
3829 }
3830
3831 for (Layout layout : layouts) {
3832 String friendlyURL = layout.getFriendlyURL();
3833
3834 if (friendlyURL.equals(PropsValues.AUTH_LOGIN_SITE_URL)) {
3835 if (themeDisplay.getLayout() == null) {
3836 break;
3837 }
3838
3839 String layoutSetFriendlyURL = getLayoutSetFriendlyURL(
3840 layout.getLayoutSet(), themeDisplay);
3841
3842 return layoutSetFriendlyURL + PropsValues.AUTH_LOGIN_SITE_URL;
3843 }
3844 }
3845
3846 return null;
3847 }
3848
3849 public String getStaticResourceURL(HttpServletRequest request, String uri) {
3850 return getStaticResourceURL(request, uri, null, 0);
3851 }
3852
3853 public String getStaticResourceURL(
3854 HttpServletRequest request, String uri, long timestamp) {
3855
3856 return getStaticResourceURL(request, uri, null, timestamp);
3857 }
3858
3859 public String getStaticResourceURL(
3860 HttpServletRequest request, String uri, String queryString) {
3861
3862 return getStaticResourceURL(request, uri, queryString, 0);
3863 }
3864
3865 public String getStaticResourceURL(
3866 HttpServletRequest request, String uri, String queryString,
3867 long timestamp) {
3868
3869 if (uri.indexOf(CharPool.QUESTION) != -1) {
3870 return uri;
3871 }
3872
3873 if (uri.startsWith(StringPool.DOUBLE_SLASH)) {
3874 uri = uri.substring(1);
3875 }
3876
3877 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
3878 WebKeys.THEME_DISPLAY);
3879
3880 Theme theme = themeDisplay.getTheme();
3881 ColorScheme colorScheme = themeDisplay.getColorScheme();
3882
3883 Map<String, String[]> parameterMap = null;
3884
3885 if (Validator.isNotNull(queryString)) {
3886 parameterMap = HttpUtil.getParameterMap(queryString);
3887 }
3888
3889 StringBundler sb = new StringBundler();
3890
3891
3892
3893 sb.append(uri);
3894 sb.append(StringPool.QUESTION);
3895
3896
3897
3898 if ((parameterMap == null) || !parameterMap.containsKey("browserId")) {
3899 sb.append("&browserId=");
3900 sb.append(BrowserSnifferUtil.getBrowserId(request));
3901 }
3902
3903
3904
3905 if ((uri.endsWith(".css") || uri.endsWith(".jsp")) &&
3906 ((parameterMap == null) || !parameterMap.containsKey("themeId"))) {
3907
3908 sb.append("&themeId=");
3909 sb.append(theme.getThemeId());
3910 }
3911
3912 if (uri.endsWith(".jsp") &&
3913 ((parameterMap == null) ||
3914 !parameterMap.containsKey("colorSchemeId"))) {
3915
3916 sb.append("&colorSchemeId=");
3917 sb.append(colorScheme.getColorSchemeId());
3918 }
3919
3920
3921
3922 if ((parameterMap == null) ||
3923 !parameterMap.containsKey("minifierType")) {
3924
3925 String minifierType = StringPool.BLANK;
3926
3927 if (uri.endsWith(".css") || uri.endsWith("css.jsp") ||
3928 (uri.endsWith(".jsp") && uri.contains("/css/"))) {
3929
3930 if (themeDisplay.isThemeCssFastLoad()) {
3931 minifierType = "css";
3932 }
3933 }
3934 else if (themeDisplay.isThemeJsFastLoad()) {
3935 minifierType = "js";
3936 }
3937
3938 if (Validator.isNotNull(minifierType)) {
3939 sb.append("&minifierType=");
3940 sb.append(minifierType);
3941 }
3942 }
3943
3944
3945
3946 if (Validator.isNotNull(queryString)) {
3947 if (!queryString.startsWith(StringPool.AMPERSAND)) {
3948 sb.append(StringPool.AMPERSAND);
3949 }
3950
3951 sb.append(queryString);
3952 }
3953
3954
3955
3956 sb.append("&languageId=");
3957 sb.append(themeDisplay.getLanguageId());
3958
3959
3960
3961 sb.append("&b=");
3962 sb.append(ReleaseInfo.getBuildNumber());
3963
3964
3965
3966 if ((parameterMap == null) || !parameterMap.containsKey("t")) {
3967 if ((timestamp == 0) && uri.startsWith(StrutsUtil.TEXT_HTML_DIR)) {
3968 ServletContext servletContext =
3969 (ServletContext)request.getAttribute(WebKeys.CTX);
3970
3971 timestamp = ServletContextUtil.getLastModified(
3972 servletContext, uri, true);
3973 }
3974
3975 if (timestamp == 0) {
3976 timestamp = theme.getTimestamp();
3977 }
3978
3979 sb.append("&t=");
3980 sb.append(timestamp);
3981 }
3982
3983 String url = sb.toString();
3984
3985 url = StringUtil.replace(url, "?&", StringPool.QUESTION);
3986
3987 return url;
3988 }
3989
3990 public String getStrutsAction(HttpServletRequest request) {
3991 String strutsAction = ParamUtil.getString(request, "struts_action");
3992
3993 if (Validator.isNotNull(strutsAction)) {
3994
3995
3996
3997
3998
3999 return StringPool.BLANK;
4000 }
4001
4002 return getPortletParam(request, "struts_action");
4003 }
4004
4005 public String[] getSystemGroups() {
4006 return _allSystemGroups;
4007 }
4008
4009 public String[] getSystemOrganizationRoles() {
4010 return _allSystemOrganizationRoles;
4011 }
4012
4013 public String[] getSystemRoles() {
4014 return _allSystemRoles;
4015 }
4016
4017 public String[] getSystemSiteRoles() {
4018 return _allSystemSiteRoles;
4019 }
4020
4021 public String getUniqueElementId(
4022 HttpServletRequest request, String namespace, String elementId) {
4023
4024 String uniqueElementId = elementId;
4025
4026 Set<String> uniqueElementIds = (Set<String>)request.getAttribute(
4027 WebKeys.UNIQUE_ELEMENT_IDS);
4028
4029 if (uniqueElementIds == null) {
4030 uniqueElementIds = new HashSet<String>();
4031
4032 request.setAttribute(WebKeys.UNIQUE_ELEMENT_IDS, uniqueElementIds);
4033 }
4034 else {
4035 int i = 1;
4036
4037 while (uniqueElementIds.contains(
4038 namespace.concat(uniqueElementId))) {
4039
4040 uniqueElementId = elementId.concat(StringPool.UNDERLINE).concat(
4041 String.valueOf(i));
4042
4043 i++;
4044 }
4045 }
4046
4047 uniqueElementIds.add(namespace.concat(uniqueElementId));
4048
4049 return uniqueElementId;
4050 }
4051
4052 public String getUniqueElementId(
4053 PortletRequest request, String namespace, String elementId) {
4054
4055 return getUniqueElementId(
4056 getHttpServletRequest(request), namespace, elementId);
4057 }
4058
4059 public UploadPortletRequest getUploadPortletRequest(
4060 PortletRequest portletRequest) {
4061
4062 PortletRequestImpl portletRequestImpl =
4063 (PortletRequestImpl)portletRequest;
4064
4065 DynamicServletRequest dynamicRequest =
4066 (DynamicServletRequest)portletRequestImpl.getHttpServletRequest();
4067
4068 HttpServletRequestWrapper requestWrapper =
4069 (HttpServletRequestWrapper)dynamicRequest.getRequest();
4070
4071 UploadServletRequest uploadServletRequest = getUploadServletRequest(
4072 requestWrapper);
4073
4074 return new UploadPortletRequestImpl(
4075 uploadServletRequest,
4076 getPortletNamespace(portletRequestImpl.getPortletName()));
4077 }
4078
4079 public UploadServletRequest getUploadServletRequest(
4080 HttpServletRequest request) {
4081
4082 HttpServletRequestWrapper requestWrapper = null;
4083
4084 if (request instanceof HttpServletRequestWrapper) {
4085 requestWrapper = (HttpServletRequestWrapper)request;
4086 }
4087
4088 UploadServletRequest uploadServletRequest = null;
4089
4090 while (uploadServletRequest == null) {
4091
4092
4093
4094
4095 if (requestWrapper instanceof UploadServletRequest) {
4096 uploadServletRequest = (UploadServletRequest)requestWrapper;
4097 }
4098 else {
4099 HttpServletRequest parentRequest =
4100 (HttpServletRequest)requestWrapper.getRequest();
4101
4102 if (!(parentRequest instanceof HttpServletRequestWrapper)) {
4103
4104
4105
4106
4107 uploadServletRequest = new UploadServletRequestImpl(
4108 parentRequest);
4109
4110 break;
4111 }
4112 else {
4113 requestWrapper = (HttpServletRequestWrapper)parentRequest;
4114 }
4115 }
4116 }
4117
4118 return uploadServletRequest;
4119 }
4120
4121 public Date getUptime() {
4122 return _upTime;
4123 }
4124
4125 public String getURLWithSessionId(String url, String sessionId) {
4126 if (!PropsValues.SESSION_ENABLE_URL_WITH_SESSION_ID) {
4127 return url;
4128 }
4129
4130 if (Validator.isNull(url)) {
4131 return url;
4132 }
4133
4134
4135
4136 int x = url.indexOf(CharPool.SEMICOLON);
4137
4138 if (x != -1) {
4139 return url;
4140 }
4141
4142 x = url.indexOf(CharPool.QUESTION);
4143
4144 if (x != -1) {
4145 StringBundler sb = new StringBundler(4);
4146
4147 sb.append(url.substring(0, x));
4148 sb.append(_JSESSIONID);
4149 sb.append(sessionId);
4150 sb.append(url.substring(x));
4151
4152 return sb.toString();
4153 }
4154
4155
4156
4157
4158 x = url.indexOf(StringPool.DOUBLE_SLASH);
4159
4160 StringBundler sb = new StringBundler(4);
4161
4162 sb.append(url);
4163
4164 if (x != -1) {
4165 int y = url.lastIndexOf(CharPool.SLASH);
4166
4167 if ((x + 1) == y) {
4168 sb.append(StringPool.SLASH);
4169 }
4170 }
4171
4172 sb.append(_JSESSIONID);
4173 sb.append(sessionId);
4174
4175 return sb.toString();
4176 }
4177
4178 public User getUser(HttpServletRequest request)
4179 throws PortalException, SystemException {
4180
4181 User user = (User)request.getAttribute(WebKeys.USER);
4182
4183 if (user != null) {
4184 return user;
4185 }
4186
4187 long userId = getUserId(request);
4188
4189 if (userId <= 0) {
4190
4191
4192
4193
4194
4195
4196 String remoteUser = request.getRemoteUser();
4197
4198 if (remoteUser == null) {
4199 return null;
4200 }
4201
4202 userId = GetterUtil.getLong(remoteUser);
4203 }
4204
4205 user = UserLocalServiceUtil.getUserById(userId);
4206
4207 request.setAttribute(WebKeys.USER, user);
4208
4209 return user;
4210 }
4211
4212 public User getUser(PortletRequest portletRequest)
4213 throws PortalException, SystemException {
4214
4215 return getUser(getHttpServletRequest(portletRequest));
4216 }
4217
4218 public String getUserEmailAddress(long userId) throws SystemException {
4219 try {
4220 User user = UserLocalServiceUtil.getUserById(userId);
4221
4222 return user.getEmailAddress();
4223 }
4224 catch (PortalException pe) {
4225 return StringPool.BLANK;
4226 }
4227 }
4228
4229 public long getUserId(HttpServletRequest request) {
4230 Long userIdObj = (Long)request.getAttribute(WebKeys.USER_ID);
4231
4232 if (userIdObj != null) {
4233 return userIdObj.longValue();
4234 }
4235
4236 String path = GetterUtil.getString(request.getPathInfo());
4237 String strutsAction = getStrutsAction(request);
4238 String actionName = getPortletParam(request, "actionName");
4239
4240 boolean alwaysAllowDoAsUser = false;
4241
4242 if (path.equals("/portal/session_click") ||
4243 strutsAction.equals("/document_library/edit_file_entry") ||
4244 strutsAction.equals("/document_library_display/edit_file_entry") ||
4245 strutsAction.equals("/image_gallery_display/edit_file_entry") ||
4246 strutsAction.equals("/image_gallery_display/edit_image") ||
4247 strutsAction.equals("/wiki/edit_page_attachment") ||
4248 strutsAction.equals("/wiki_admin/edit_page_attachment") ||
4249 strutsAction.equals("/wiki_display/edit_page_attachment") ||
4250 actionName.equals("addFile")) {
4251
4252 try {
4253 alwaysAllowDoAsUser = isAlwaysAllowDoAsUser(request);
4254 }
4255 catch (Exception e) {
4256 _log.error(e, e);
4257 }
4258 }
4259
4260 if ((!PropsValues.PORTAL_JAAS_ENABLE &&
4261 PropsValues.PORTAL_IMPERSONATION_ENABLE) ||
4262 alwaysAllowDoAsUser) {
4263
4264 String doAsUserIdString = ParamUtil.getString(
4265 request, "doAsUserId");
4266
4267 try {
4268 long doAsUserId = getDoAsUserId(
4269 request, doAsUserIdString, alwaysAllowDoAsUser);
4270
4271 if (doAsUserId > 0) {
4272 if (_log.isDebugEnabled()) {
4273 _log.debug("Impersonating user " + doAsUserId);
4274 }
4275
4276 return doAsUserId;
4277 }
4278 }
4279 catch (Exception e) {
4280 _log.error("Unable to impersonate user " + doAsUserIdString, e);
4281 }
4282 }
4283
4284 HttpSession session = request.getSession();
4285
4286 String jRemoteUser = null;
4287
4288 if (PropsValues.PORTAL_JAAS_ENABLE) {
4289 jRemoteUser = (String)session.getAttribute("j_remoteuser");
4290 }
4291
4292 if (Validator.isNotNull(jRemoteUser)) {
4293 userIdObj = GetterUtil.getLong(jRemoteUser);
4294 }
4295 else {
4296 userIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
4297 }
4298
4299 if (userIdObj != null) {
4300 request.setAttribute(WebKeys.USER_ID, userIdObj);
4301
4302 return userIdObj.longValue();
4303 }
4304 else {
4305 return 0;
4306 }
4307 }
4308
4309 public long getUserId(PortletRequest portletRequest) {
4310 return getUserId(getHttpServletRequest(portletRequest));
4311 }
4312
4313 public String getUserName(BaseModel<?> baseModel) {
4314 long userId = 0;
4315 String userName = StringPool.BLANK;
4316
4317 if (baseModel instanceof AuditedModel) {
4318 AuditedModel auditedModel = (AuditedModel)baseModel;
4319
4320 userId = auditedModel.getUserId();
4321 userName = auditedModel.getUserName();
4322 }
4323 else {
4324 userId = BeanPropertiesUtil.getLongSilent(baseModel, "userId");
4325 userName = BeanPropertiesUtil.getStringSilent(
4326 baseModel, "userName");
4327 }
4328
4329 if (userId == 0) {
4330 return StringPool.BLANK;
4331 }
4332
4333 if (baseModel.isEscapedModel()) {
4334 userName = HtmlUtil.unescape(userName);
4335 }
4336
4337 userName = getUserName(userId, userName);
4338
4339 if (baseModel.isEscapedModel()) {
4340 userName = HtmlUtil.escape(userName);
4341 }
4342
4343 return userName;
4344 }
4345
4346 public String getUserName(long userId, String defaultUserName) {
4347 return getUserName(
4348 userId, defaultUserName, UserAttributes.USER_NAME_FULL);
4349 }
4350
4351 public String getUserName(
4352 long userId, String defaultUserName, HttpServletRequest request) {
4353
4354 return getUserName(
4355 userId, defaultUserName, UserAttributes.USER_NAME_FULL, request);
4356 }
4357
4358 public String getUserName(
4359 long userId, String defaultUserName, String userAttribute) {
4360
4361 return getUserName(userId, defaultUserName, userAttribute, null);
4362 }
4363
4364 public String getUserName(
4365 long userId, String defaultUserName, String userAttribute,
4366 HttpServletRequest request) {
4367
4368 String userName = defaultUserName;
4369
4370 try {
4371 User user = UserLocalServiceUtil.getUserById(userId);
4372
4373 if (userAttribute.equals(UserAttributes.USER_NAME_FULL)) {
4374 userName = user.getFullName();
4375 }
4376 else {
4377 userName = user.getScreenName();
4378 }
4379
4380 if (request != null) {
4381 Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
4382
4383 PortletURL portletURL = new PortletURLImpl(
4384 request, PortletKeys.DIRECTORY, layout.getPlid(),
4385 PortletRequest.RENDER_PHASE);
4386
4387 portletURL.setWindowState(WindowState.MAXIMIZED);
4388 portletURL.setPortletMode(PortletMode.VIEW);
4389
4390 portletURL.setParameter(
4391 "struts_action", "/directory/view_user");
4392 portletURL.setParameter(
4393 "p_u_i_d", String.valueOf(user.getUserId()));
4394
4395 userName =
4396 "<a href=\"" + portletURL.toString() + "\">" +
4397 HtmlUtil.escape(userName) + "</a>";
4398 }
4399 }
4400 catch (Exception e) {
4401 }
4402
4403 return userName;
4404 }
4405
4406 public String getUserPassword(HttpServletRequest request) {
4407 HttpSession session = request.getSession();
4408
4409 return getUserPassword(session);
4410 }
4411
4412 public String getUserPassword(HttpSession session) {
4413 return (String)session.getAttribute(WebKeys.USER_PASSWORD);
4414 }
4415
4416 public String getUserPassword(PortletRequest portletRequest) {
4417 return getUserPassword(getHttpServletRequest(portletRequest));
4418 }
4419
4420 public String getUserValue(long userId, String param, String defaultValue)
4421 throws SystemException {
4422
4423 if (Validator.isNotNull(defaultValue)) {
4424 return defaultValue;
4425 }
4426 else {
4427 try {
4428 User user = UserLocalServiceUtil.getUserById(userId);
4429
4430 return BeanPropertiesUtil.getString(user, param, defaultValue);
4431 }
4432 catch (PortalException pe) {
4433 return StringPool.BLANK;
4434 }
4435 }
4436 }
4437
4438 public long getValidUserId(long companyId, long userId)
4439 throws PortalException, SystemException {
4440
4441 try {
4442 User user = UserLocalServiceUtil.getUser(userId);
4443
4444 if (user.getCompanyId() == companyId) {
4445 return user.getUserId();
4446 }
4447 else {
4448 return userId;
4449 }
4450 }
4451 catch (NoSuchUserException nsue) {
4452 return UserLocalServiceUtil.getDefaultUserId(companyId);
4453 }
4454 }
4455
4456 public String getVirtualLayoutActualURL(
4457 long groupId, boolean privateLayout, String mainPath,
4458 String friendlyURL, Map<String, String[]> params,
4459 Map<String, Object> requestContext)
4460 throws PortalException, SystemException {
4461
4462
4463
4464 String groupFriendlyURL = null;
4465
4466 int pos = friendlyURL.indexOf(CharPool.SLASH, 3);
4467
4468 if (pos != -1) {
4469 groupFriendlyURL = friendlyURL.substring(2, pos);
4470 }
4471
4472 if (Validator.isNull(groupFriendlyURL)) {
4473 return mainPath;
4474 }
4475
4476 HttpServletRequest request = (HttpServletRequest)requestContext.get(
4477 "request");
4478
4479 long companyId = PortalInstances.getCompanyId(request);
4480
4481 Group group = GroupLocalServiceUtil.fetchFriendlyURLGroup(
4482 companyId, groupFriendlyURL);
4483
4484 if (group == null) {
4485 return mainPath;
4486 }
4487
4488
4489
4490 String layoutFriendlyURL = null;
4491
4492 if ((pos != -1) && ((pos + 1) != friendlyURL.length())) {
4493 layoutFriendlyURL = friendlyURL.substring(pos);
4494 }
4495
4496 if (Validator.isNull(layoutFriendlyURL)) {
4497 return mainPath;
4498 }
4499
4500 String actualURL = getActualURL(
4501 group.getGroupId(), privateLayout, mainPath, layoutFriendlyURL,
4502 params, requestContext);
4503
4504 return HttpUtil.addParameter(
4505 HttpUtil.removeParameter(actualURL, "p_v_l_s_g_id"), "p_v_l_s_g_id",
4506 groupId);
4507 }
4508
4509 public String getWidgetURL(Portlet portlet, ThemeDisplay themeDisplay)
4510 throws PortalException, SystemException {
4511
4512 return getServletURL(
4513 portlet, PropsValues.WIDGET_SERVLET_MAPPING, themeDisplay);
4514 }
4515
4516 public void initCustomSQL() {
4517 _customSqlKeys = new String[] {
4518 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.GROUP$]",
4519 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.LAYOUT$]",
4520 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ORGANIZATION$]",
4521 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ROLE$]",
4522 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USER$]",
4523 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USERGROUP$]",
4524 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BLOGS.MODEL.BLOGSENTRY$]",
4525 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BOOKMARKS.MODEL." +
4526 "BOOKMARKSENTRY$]",
4527 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.CALENDAR.MODEL.CALEVENT$]",
4528 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.DOCUMENTLIBRARY.MODEL." +
4529 "DLFILEENTRY$]",
4530 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.MESSAGEBOARDS.MODEL." +
4531 "MBMESSAGE$]",
4532 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.MESSAGEBOARDS.MODEL." +
4533 "MBTHREAD$]",
4534 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.WIKI.MODEL.WIKIPAGE$]",
4535 "[$RESOURCE_SCOPE_COMPANY$]", "[$RESOURCE_SCOPE_GROUP$]",
4536 "[$RESOURCE_SCOPE_GROUP_TEMPLATE$]",
4537 "[$RESOURCE_SCOPE_INDIVIDUAL$]",
4538 "[$SOCIAL_RELATION_TYPE_BI_COWORKER$]",
4539 "[$SOCIAL_RELATION_TYPE_BI_FRIEND$]",
4540 "[$SOCIAL_RELATION_TYPE_BI_ROMANTIC_PARTNER$]",
4541 "[$SOCIAL_RELATION_TYPE_BI_SIBLING$]",
4542 "[$SOCIAL_RELATION_TYPE_BI_SPOUSE$]",
4543 "[$SOCIAL_RELATION_TYPE_UNI_CHILD$]",
4544 "[$SOCIAL_RELATION_TYPE_UNI_ENEMY$]",
4545 "[$SOCIAL_RELATION_TYPE_UNI_FOLLOWER$]",
4546 "[$SOCIAL_RELATION_TYPE_UNI_PARENT$]",
4547 "[$SOCIAL_RELATION_TYPE_UNI_SUBORDINATE$]",
4548 "[$SOCIAL_RELATION_TYPE_UNI_SUPERVISOR$]", "[$FALSE$]", "[$TRUE$]"
4549 };
4550
4551 DB db = DBFactoryUtil.getDB();
4552
4553 Object[] customSqlValues = new Object[] {
4554 getClassNameId(Group.class), getClassNameId(Layout.class),
4555 getClassNameId(Organization.class), getClassNameId(Role.class),
4556 getClassNameId(User.class), getClassNameId(UserGroup.class),
4557 getClassNameId(BlogsEntry.class),
4558 getClassNameId(BookmarksEntry.class),
4559 getClassNameId(CalEvent.class), getClassNameId(DLFileEntry.class),
4560 getClassNameId(MBMessage.class), getClassNameId(MBThread.class),
4561 getClassNameId(WikiPage.class), ResourceConstants.SCOPE_COMPANY,
4562 ResourceConstants.SCOPE_GROUP,
4563 ResourceConstants.SCOPE_GROUP_TEMPLATE,
4564 ResourceConstants.SCOPE_INDIVIDUAL,
4565 SocialRelationConstants.TYPE_BI_COWORKER,
4566 SocialRelationConstants.TYPE_BI_FRIEND,
4567 SocialRelationConstants.TYPE_BI_ROMANTIC_PARTNER,
4568 SocialRelationConstants.TYPE_BI_SIBLING,
4569 SocialRelationConstants.TYPE_BI_SPOUSE,
4570 SocialRelationConstants.TYPE_UNI_CHILD,
4571 SocialRelationConstants.TYPE_UNI_ENEMY,
4572 SocialRelationConstants.TYPE_UNI_FOLLOWER,
4573 SocialRelationConstants.TYPE_UNI_PARENT,
4574 SocialRelationConstants.TYPE_UNI_SUBORDINATE,
4575 SocialRelationConstants.TYPE_UNI_SUPERVISOR, db.getTemplateFalse(),
4576 db.getTemplateTrue()
4577 };
4578
4579 _customSqlValues = ArrayUtil.toStringArray(customSqlValues);
4580 }
4581
4582 public boolean isAllowAddPortletDefaultResource(
4583 HttpServletRequest request, Portlet portlet)
4584 throws PortalException, SystemException {
4585
4586 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
4587 WebKeys.THEME_DISPLAY);
4588
4589 Layout layout = themeDisplay.getLayout();
4590 LayoutTypePortlet layoutTypePortlet =
4591 themeDisplay.getLayoutTypePortlet();
4592
4593 String portletId = portlet.getPortletId();
4594
4595 Boolean renderPortletResource = (Boolean)request.getAttribute(
4596 WebKeys.RENDER_PORTLET_RESOURCE);
4597
4598 if (renderPortletResource != null) {
4599 boolean runtimePortlet = renderPortletResource.booleanValue();
4600
4601 if (runtimePortlet) {
4602 return true;
4603 }
4604 }
4605
4606 if (layout.isTypePanel() &&
4607 isPanelSelectedPortlet(themeDisplay, portletId)) {
4608
4609 return true;
4610 }
4611
4612 if (layout.isTypeControlPanel() &&
4613 isControlPanelPortlet(portletId, themeDisplay)) {
4614
4615 return true;
4616 }
4617
4618 if ((layoutTypePortlet != null) &&
4619 layoutTypePortlet.hasPortletId(portletId)) {
4620
4621 return true;
4622 }
4623
4624 if (themeDisplay.isSignedIn() &&
4625 (portletId.equals(PortletKeys.LAYOUT_CONFIGURATION) ||
4626 portletId.equals(PortletKeys.LAYOUTS_ADMIN))) {
4627
4628 PermissionChecker permissionChecker =
4629 themeDisplay.getPermissionChecker();
4630
4631 Group group = layout.getGroup();
4632
4633 if (group.isSite()) {
4634 if (LayoutPermissionUtil.contains(
4635 permissionChecker, layout, ActionKeys.CUSTOMIZE) ||
4636 LayoutPermissionUtil.contains(
4637 permissionChecker, layout, ActionKeys.UPDATE)) {
4638
4639 return true;
4640 }
4641 }
4642
4643 if (group.isCompany()) {
4644 if (permissionChecker.isCompanyAdmin()) {
4645 return true;
4646 }
4647 }
4648 else if (group.isLayoutPrototype()) {
4649 long layoutPrototypeId = group.getClassPK();
4650
4651 if (LayoutPrototypePermissionUtil.contains(
4652 permissionChecker, layoutPrototypeId,
4653 ActionKeys.UPDATE)) {
4654
4655 return true;
4656 }
4657 }
4658 else if (group.isLayoutSetPrototype()) {
4659 long layoutSetPrototypeId = group.getClassPK();
4660
4661 if (LayoutSetPrototypePermissionUtil.contains(
4662 permissionChecker, layoutSetPrototypeId,
4663 ActionKeys.UPDATE)) {
4664
4665 return true;
4666 }
4667 }
4668 else if (group.isOrganization()) {
4669 long organizationId = group.getOrganizationId();
4670
4671 if (OrganizationPermissionUtil.contains(
4672 permissionChecker, organizationId, ActionKeys.UPDATE)) {
4673
4674 return true;
4675 }
4676 }
4677 else if (group.isUserGroup()) {
4678 long scopeGroupId = themeDisplay.getScopeGroupId();
4679
4680 if (GroupPermissionUtil.contains(
4681 permissionChecker, scopeGroupId, ActionKeys.UPDATE)) {
4682
4683 return true;
4684 }
4685 }
4686 else if (group.isUser()) {
4687 return true;
4688 }
4689 }
4690
4691 if (!portlet.isAddDefaultResource()) {
4692 return false;
4693 }
4694
4695 if (!PropsValues.PORTLET_ADD_DEFAULT_RESOURCE_CHECK_ENABLED) {
4696 return true;
4697 }
4698
4699 if (_portletAddDefaultResourceCheckWhitelist.contains(portletId)) {
4700 return true;
4701 }
4702
4703 String namespace = getPortletNamespace(portletId);
4704
4705 String strutsAction = ParamUtil.getString(
4706 request, namespace + "struts_action");
4707
4708 if (Validator.isNull(strutsAction)) {
4709 strutsAction = ParamUtil.getString(request, "struts_action");
4710 }
4711
4712 if (_portletAddDefaultResourceCheckWhitelistActions.contains(
4713 strutsAction)) {
4714
4715 return true;
4716 }
4717
4718 String requestPortletAuthenticationToken = ParamUtil.getString(
4719 request, "p_p_auth");
4720
4721 if (Validator.isNull(requestPortletAuthenticationToken)) {
4722 HttpServletRequest originalRequest = getOriginalServletRequest(
4723 request);
4724
4725 requestPortletAuthenticationToken = ParamUtil.getString(
4726 originalRequest, "p_p_auth");
4727 }
4728
4729 if (Validator.isNotNull(requestPortletAuthenticationToken)) {
4730 String actualPortletAuthenticationToken = AuthTokenUtil.getToken(
4731 request, layout.getPlid(), portletId);
4732
4733 if (requestPortletAuthenticationToken.equals(
4734 actualPortletAuthenticationToken)) {
4735
4736 return true;
4737 }
4738 }
4739
4740 return false;
4741 }
4742
4743 public boolean isCDNDynamicResourcesEnabled(HttpServletRequest request)
4744 throws PortalException, SystemException {
4745
4746 Company company = getCompany(request);
4747
4748 return isCDNDynamicResourcesEnabled(company.getCompanyId());
4749 }
4750
4751 public boolean isCDNDynamicResourcesEnabled(long companyId) {
4752 try {
4753 return PrefsPropsUtil.getBoolean(
4754 companyId, PropsKeys.CDN_DYNAMIC_RESOURCES_ENABLED,
4755 PropsValues.CDN_DYNAMIC_RESOURCES_ENABLED);
4756 }
4757 catch (SystemException se) {
4758 }
4759
4760 return PropsValues.CDN_DYNAMIC_RESOURCES_ENABLED;
4761 }
4762
4763
4766 public boolean isCommunityAdmin(User user, long groupId) throws Exception {
4767 return isGroupAdmin(user, groupId);
4768 }
4769
4770
4773 public boolean isCommunityOwner(User user, long groupId) throws Exception {
4774 return isGroupOwner(user, groupId);
4775 }
4776
4777 public boolean isCompanyAdmin(User user) throws Exception {
4778 PermissionChecker permissionChecker =
4779 PermissionCheckerFactoryUtil.create(user);
4780
4781 return permissionChecker.isCompanyAdmin();
4782 }
4783
4784 public boolean isCompanyControlPanelPortlet(
4785 String portletId, String category, ThemeDisplay themeDisplay)
4786 throws PortalException, SystemException {
4787
4788 PermissionChecker permissionChecker =
4789 themeDisplay.getPermissionChecker();
4790
4791 if (permissionChecker.isCompanyAdmin()) {
4792 return true;
4793 }
4794
4795 Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
4796 themeDisplay.getCompanyId());
4797
4798 themeDisplay.setScopeGroupId(companyGroup.getGroupId());
4799
4800 return isControlPanelPortlet(portletId, category, themeDisplay);
4801 }
4802
4803 public boolean isCompanyControlPanelPortlet(
4804 String portletId, ThemeDisplay themeDisplay)
4805 throws PortalException, SystemException {
4806
4807 PermissionChecker permissionChecker =
4808 themeDisplay.getPermissionChecker();
4809
4810 if (permissionChecker.isCompanyAdmin()) {
4811 return true;
4812 }
4813
4814 Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
4815 themeDisplay.getCompanyId());
4816
4817 themeDisplay.setScopeGroupId(companyGroup.getGroupId());
4818
4819 return isControlPanelPortlet(portletId, themeDisplay);
4820 }
4821
4822 public boolean isCompanyControlPanelVisible(ThemeDisplay themeDisplay)
4823 throws PortalException, SystemException {
4824
4825 PermissionChecker permissionChecker =
4826 themeDisplay.getPermissionChecker();
4827
4828 if (permissionChecker.isCompanyAdmin()) {
4829 return true;
4830 }
4831
4832 long scopeGroupId = themeDisplay.getScopeGroupId();
4833
4834 try {
4835 Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
4836 themeDisplay.getCompanyId());
4837
4838 themeDisplay.setScopeGroupId(companyGroup.getGroupId());
4839
4840 List<Portlet> controlPanelPortlets = getControlPanelPortlets(
4841 PortletCategoryKeys.CONTENT, themeDisplay);
4842
4843 if (!controlPanelPortlets.isEmpty()) {
4844 return true;
4845 }
4846 else {
4847 return false;
4848 }
4849 }
4850 finally {
4851 themeDisplay.setScopeGroupId(scopeGroupId);
4852 }
4853 }
4854
4855 public boolean isControlPanelPortlet(
4856 String portletId, String category, ThemeDisplay themeDisplay)
4857 throws SystemException {
4858
4859 List<Portlet> portlets = getControlPanelPortlets(
4860 category, themeDisplay);
4861
4862 for (Portlet portlet : portlets) {
4863 if (portlet.getPortletId().equals(portletId)) {
4864 return true;
4865 }
4866 }
4867
4868 return false;
4869 }
4870
4871 public boolean isControlPanelPortlet(
4872 String portletId, ThemeDisplay themeDisplay)
4873 throws SystemException {
4874
4875 for (String category : PortletCategoryKeys.ALL) {
4876 if (isControlPanelPortlet(portletId, category, themeDisplay)) {
4877 return true;
4878 }
4879 }
4880
4881 return false;
4882 }
4883
4884 public boolean isGroupAdmin(User user, long groupId) throws Exception {
4885 PermissionChecker permissionChecker =
4886 PermissionCheckerFactoryUtil.create(user);
4887
4888 return permissionChecker.isGroupAdmin(groupId);
4889 }
4890
4891 public boolean isGroupOwner(User user, long groupId) throws Exception {
4892 PermissionChecker permissionChecker =
4893 PermissionCheckerFactoryUtil.create(user);
4894
4895 return permissionChecker.isGroupOwner(groupId);
4896 }
4897
4898 public boolean isLayoutDescendant(Layout layout, long layoutId)
4899 throws PortalException, SystemException {
4900
4901 if (layout.getLayoutId() == layoutId) {
4902 return true;
4903 }
4904 else {
4905 for (Layout childLayout : layout.getChildren()) {
4906 if (isLayoutDescendant(childLayout, layoutId)) {
4907 return true;
4908 }
4909 }
4910
4911 return false;
4912 }
4913 }
4914
4915 public boolean isLayoutFirstPageable(Layout layout) {
4916 LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
4917
4918 return layoutSettings.isFirstPageable();
4919 }
4920
4921 public boolean isLayoutFirstPageable(String type) {
4922 LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
4923
4924 return layoutSettings.isFirstPageable();
4925 }
4926
4927 public boolean isLayoutFriendliable(Layout layout) {
4928 LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
4929
4930 return layoutSettings.isURLFriendliable();
4931 }
4932
4933 public boolean isLayoutFriendliable(String type) {
4934 LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
4935
4936 return layoutSettings.isURLFriendliable();
4937 }
4938
4939 public boolean isLayoutParentable(Layout layout) {
4940 return isLayoutParentable(layout.getType());
4941 }
4942
4943 public boolean isLayoutParentable(String type) {
4944 LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
4945
4946 return layoutSettings.isParentable();
4947 }
4948
4949 public boolean isLayoutSitemapable(Layout layout) {
4950 if (layout.isPrivateLayout()) {
4951 return false;
4952 }
4953
4954 LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
4955
4956 return layoutSettings.isSitemapable();
4957 }
4958
4959 public boolean isMethodGet(PortletRequest portletRequest) {
4960 HttpServletRequest request = getHttpServletRequest(portletRequest);
4961
4962 String method = GetterUtil.getString(request.getMethod());
4963
4964 if (method.equalsIgnoreCase(HttpMethods.GET)) {
4965 return true;
4966 }
4967 else {
4968 return false;
4969 }
4970 }
4971
4972 public boolean isMethodPost(PortletRequest portletRequest) {
4973 HttpServletRequest request = getHttpServletRequest(portletRequest);
4974
4975 String method = GetterUtil.getString(request.getMethod());
4976
4977 if (method.equalsIgnoreCase(HttpMethods.POST)) {
4978 return true;
4979 }
4980 else {
4981 return false;
4982 }
4983 }
4984
4985 public boolean isMultipartRequest(HttpServletRequest request) {
4986 String contentType = request.getHeader(HttpHeaders.CONTENT_TYPE);
4987
4988 if ((contentType != null) &&
4989 contentType.startsWith(ContentTypes.MULTIPART_FORM_DATA)) {
4990
4991 return true;
4992 }
4993 else {
4994 return false;
4995 }
4996 }
4997
4998 public boolean isOmniadmin(long userId) {
4999 return OmniadminUtil.isOmniadmin(userId);
5000 }
5001
5002 public boolean isReservedParameter(String name) {
5003 return _reservedParams.contains(name);
5004 }
5005
5006 public boolean isRSSFeedsEnabled() {
5007 return PropsValues.RSS_FEEDS_ENABLED;
5008 }
5009
5010 public boolean isSecure(HttpServletRequest request) {
5011 HttpSession session = request.getSession();
5012
5013 Boolean httpsInitial = (Boolean)session.getAttribute(
5014 WebKeys.HTTPS_INITIAL);
5015
5016 boolean secure = false;
5017
5018 if (PropsValues.COMPANY_SECURITY_AUTH_REQUIRES_HTTPS &&
5019 !PropsValues.SESSION_ENABLE_PHISHING_PROTECTION &&
5020 (httpsInitial != null) && !httpsInitial.booleanValue()) {
5021
5022 secure = false;
5023 }
5024 else {
5025 secure = request.isSecure();
5026 }
5027
5028 return secure;
5029 }
5030
5031 public boolean isSystemGroup(String groupName) {
5032 if (groupName == null) {
5033 return false;
5034 }
5035
5036 groupName = groupName.trim();
5037
5038 int pos = Arrays.binarySearch(
5039 _sortedSystemGroups, groupName, new StringComparator());
5040
5041 if (pos >= 0) {
5042 return true;
5043 }
5044 else {
5045 return false;
5046 }
5047 }
5048
5049 public boolean isSystemRole(String roleName) {
5050 if (roleName == null) {
5051 return false;
5052 }
5053
5054 roleName = roleName.trim();
5055
5056 int pos = Arrays.binarySearch(
5057 _sortedSystemRoles, roleName, new StringComparator());
5058
5059 if (pos >= 0) {
5060 return true;
5061 }
5062 else {
5063 pos = Arrays.binarySearch(
5064 _sortedSystemSiteRoles, roleName, new StringComparator());
5065
5066 if (pos >= 0) {
5067 return true;
5068 }
5069 else {
5070 pos = Arrays.binarySearch(
5071 _sortedSystemOrganizationRoles, roleName,
5072 new StringComparator());
5073
5074 if (pos >= 0) {
5075 return true;
5076 }
5077 }
5078 }
5079
5080 return false;
5081 }
5082
5083 public boolean isUpdateAvailable() throws SystemException {
5084 return PluginPackageUtil.isUpdateAvailable();
5085 }
5086
5087 public boolean isValidResourceId(String resourceId) {
5088 if (Validator.isNull(resourceId)) {
5089 return true;
5090 }
5091
5092 Matcher matcher = _bannedResourceIdPattern.matcher(resourceId);
5093
5094 if (matcher.matches()) {
5095 return false;
5096 }
5097
5098 return true;
5099 }
5100
5101 public void removePortalPortEventListener(
5102 PortalPortEventListener portalPortEventListener) {
5103
5104 _portalPortEventListeners.remove(portalPortEventListener);
5105 }
5106
5107 public void resetCDNHosts() {
5108 _cdnHostHttpMap.clear();
5109 _cdnHostHttpsMap.clear();
5110
5111 if (!ClusterInvokeThreadLocal.isEnabled()) {
5112 return;
5113 }
5114
5115 ClusterRequest clusterRequest = ClusterRequest.createMulticastRequest(
5116 _resetCDNHostsMethodHandler, true);
5117
5118 try {
5119 ClusterExecutorUtil.execute(clusterRequest);
5120 }
5121 catch (Exception e) {
5122 _log.error("Unable to clear cluster wide CDN hosts", e);
5123 }
5124 }
5125
5126 public Set<String> resetPortletAddDefaultResourceCheckWhitelist() {
5127 _portletAddDefaultResourceCheckWhitelist = SetUtil.fromArray(
5128 PropsValues.PORTLET_ADD_DEFAULT_RESOURCE_CHECK_WHITELIST);
5129
5130 _portletAddDefaultResourceCheckWhitelist = Collections.unmodifiableSet(
5131 _portletAddDefaultResourceCheckWhitelist);
5132
5133 return _portletAddDefaultResourceCheckWhitelist;
5134 }
5135
5136 public Set<String> resetPortletAddDefaultResourceCheckWhitelistActions() {
5137 _portletAddDefaultResourceCheckWhitelistActions = SetUtil.fromArray(
5138 PropsValues.PORTLET_ADD_DEFAULT_RESOURCE_CHECK_WHITELIST_ACTIONS);
5139
5140 _portletAddDefaultResourceCheckWhitelistActions =
5141 Collections.unmodifiableSet(
5142 _portletAddDefaultResourceCheckWhitelistActions);
5143
5144 return _portletAddDefaultResourceCheckWhitelistActions;
5145 }
5146
5147 public void sendError(
5148 Exception e, ActionRequest actionRequest,
5149 ActionResponse actionResponse)
5150 throws IOException {
5151
5152 sendError(0, e, actionRequest, actionResponse);
5153 }
5154
5155 public void sendError(
5156 Exception e, HttpServletRequest request,
5157 HttpServletResponse response)
5158 throws IOException, ServletException {
5159
5160 sendError(0, e, request, response);
5161 }
5162
5163 public void sendError(
5164 int status, Exception e, ActionRequest actionRequest,
5165 ActionResponse actionResponse)
5166 throws IOException {
5167
5168 StringBundler sb = new StringBundler(7);
5169
5170 sb.append(_pathMain);
5171 sb.append("/portal/status?status=");
5172 sb.append(status);
5173 sb.append("&exception=");
5174 sb.append(e.getClass().getName());
5175 sb.append("&previousURL=");
5176 sb.append(HttpUtil.encodeURL(getCurrentURL(actionRequest)));
5177
5178 actionResponse.sendRedirect(sb.toString());
5179 }
5180
5181 public void sendError(
5182 int status, Exception e, HttpServletRequest request,
5183 HttpServletResponse response)
5184 throws IOException, ServletException {
5185
5186 if (_log.isDebugEnabled()) {
5187 String currentURL = (String)request.getAttribute(
5188 WebKeys.CURRENT_URL);
5189
5190 _log.debug(
5191 "Current URL " + currentURL + " generates exception: " +
5192 e.getMessage());
5193 }
5194
5195 if (e instanceof NoSuchImageException) {
5196 if (_logWebServerServlet.isWarnEnabled()) {
5197 _logWebServerServlet.warn(e, e);
5198 }
5199 }
5200 else if ((e instanceof PortalException) && _log.isDebugEnabled()) {
5201 if ((e instanceof NoSuchLayoutException) ||
5202 (e instanceof PrincipalException)) {
5203
5204 String msg = e.getMessage();
5205
5206 if (Validator.isNotNull(msg)) {
5207 _log.debug(msg);
5208 }
5209 }
5210 else {
5211 _log.debug(e, e);
5212 }
5213 }
5214 else if ((e instanceof SystemException) && _log.isWarnEnabled()) {
5215 _log.warn(e, e);
5216 }
5217
5218 if (response.isCommitted()) {
5219 return;
5220 }
5221
5222 if (status == 0) {
5223 if (e instanceof PrincipalException) {
5224 status = HttpServletResponse.SC_FORBIDDEN;
5225 }
5226 else {
5227 String name = e.getClass().getName();
5228
5229 name = name.substring(name.lastIndexOf(CharPool.PERIOD) + 1);
5230
5231 if (name.startsWith("NoSuch") && name.endsWith("Exception")) {
5232 status = HttpServletResponse.SC_NOT_FOUND;
5233 }
5234 }
5235
5236 if (status == 0) {
5237
5238
5239
5240 if (PropsValues.TCK_URL) {
5241 status = HttpServletResponse.SC_INTERNAL_SERVER_ERROR;
5242 }
5243 else {
5244 status = HttpServletResponse.SC_BAD_REQUEST;
5245 }
5246 }
5247 }
5248
5249 HttpSession session = PortalSessionThreadLocal.getHttpSession();
5250
5251 if (session == null) {
5252 session = request.getSession();
5253 }
5254
5255 ServletContext servletContext = session.getServletContext();
5256
5257 String redirect = PATH_MAIN + "/portal/status";
5258
5259 if ((e instanceof NoSuchLayoutException) &&
5260 Validator.isNotNull(
5261 PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND)) {
5262
5263 response.setStatus(status);
5264
5265 redirect = PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND;
5266
5267 RequestDispatcher requestDispatcher =
5268 servletContext.getRequestDispatcher(redirect);
5269
5270 if (requestDispatcher != null) {
5271 requestDispatcher.forward(request, response);
5272 }
5273 }
5274 else if (PropsValues.LAYOUT_SHOW_HTTP_STATUS) {
5275 response.setStatus(status);
5276
5277 SessionErrors.add(session, e.getClass(), e);
5278
5279 RequestDispatcher requestDispatcher =
5280 servletContext.getRequestDispatcher(redirect);
5281
5282 if (requestDispatcher != null) {
5283 requestDispatcher.forward(request, response);
5284 }
5285 }
5286 else {
5287 if (e != null) {
5288 response.sendError(status, e.getMessage());
5289 }
5290 else {
5291 response.sendError(status);
5292 }
5293 }
5294 }
5295
5296 public void sendRSSFeedsDisabledError(
5297 HttpServletRequest request, HttpServletResponse response)
5298 throws IOException, ServletException {
5299
5300 PortalUtil.sendError(
5301 HttpServletResponse.SC_NOT_FOUND, new NoSuchFeedException(),
5302 request, response);
5303 }
5304
5305 public void sendRSSFeedsDisabledError(
5306 PortletRequest portletRequest, PortletResponse portletResponse)
5307 throws IOException, ServletException {
5308
5309 HttpServletRequest request = PortalUtil.getHttpServletRequest(
5310 portletRequest);
5311 HttpServletResponse response = PortalUtil.getHttpServletResponse(
5312 portletResponse);
5313
5314 sendRSSFeedsDisabledError(request, response);
5315 }
5316
5317 public void setPageDescription(
5318 String description, HttpServletRequest request) {
5319
5320 ListMergeable<String> descriptionListMergeable =
5321 new ListMergeable<String>();
5322
5323 descriptionListMergeable.add(description);
5324
5325 request.setAttribute(
5326 WebKeys.PAGE_DESCRIPTION, descriptionListMergeable);
5327 }
5328
5329 public void setPageKeywords(String keywords, HttpServletRequest request) {
5330 request.removeAttribute(WebKeys.PAGE_KEYWORDS);
5331
5332 addPageKeywords(keywords, request);
5333 }
5334
5335 public void setPageSubtitle(String subtitle, HttpServletRequest request) {
5336 ListMergeable<String> subtitleListMergeable =
5337 new ListMergeable<String>();
5338
5339 subtitleListMergeable.add(subtitle);
5340
5341 request.setAttribute(WebKeys.PAGE_SUBTITLE, subtitleListMergeable);
5342 }
5343
5344 public void setPageTitle(String title, HttpServletRequest request) {
5345 ListMergeable<String> titleListMergeable = new ListMergeable<String>();
5346
5347 titleListMergeable.add(title);
5348
5349 request.setAttribute(WebKeys.PAGE_TITLE, titleListMergeable);
5350 }
5351
5352 public void setPortalPort(HttpServletRequest request) {
5353 if (request.isSecure()) {
5354 if (_securePortalPort.get() == -1) {
5355 int securePortalPort = request.getServerPort();
5356
5357 _securePortalPort.compareAndSet(-1, securePortalPort);
5358 }
5359 }
5360 else {
5361 if (_portalPort.get() == -1) {
5362 int portalPort = request.getServerPort();
5363
5364 if (_portalPort.compareAndSet(-1, portalPort)) {
5365 notifyPortalPortEventListeners(portalPort);
5366 }
5367 }
5368 }
5369 }
5370
5371 public void storePreferences(PortletPreferences portletPreferences)
5372 throws IOException, ValidatorException {
5373
5374 PortletPreferencesWrapper portletPreferencesWrapper =
5375 (PortletPreferencesWrapper)portletPreferences;
5376
5377 PortletPreferencesImpl portletPreferencesImpl =
5378 portletPreferencesWrapper.getPortletPreferencesImpl();
5379
5380 portletPreferencesImpl.store();
5381 }
5382
5383 public String[] stripURLAnchor(String url, String separator) {
5384 String anchor = StringPool.BLANK;
5385
5386 int pos = url.indexOf(separator);
5387
5388 if (pos != -1) {
5389 anchor = url.substring(pos);
5390 url = url.substring(0, pos);
5391 }
5392
5393 return new String[] {url, anchor};
5394 }
5395
5396 public String transformCustomSQL(String sql) {
5397 if ((_customSqlKeys == null) || (_customSqlValues == null)) {
5398 initCustomSQL();
5399 }
5400
5401 return StringUtil.replace(sql, _customSqlKeys, _customSqlValues);
5402 }
5403
5404 public PortletMode updatePortletMode(
5405 String portletId, User user, Layout layout, PortletMode portletMode,
5406 HttpServletRequest request) {
5407
5408 LayoutTypePortlet layoutType =
5409 (LayoutTypePortlet)layout.getLayoutType();
5410
5411 if ((portletMode == null) || Validator.isNull(portletMode.toString())) {
5412 if (layoutType.hasModeAboutPortletId(portletId)) {
5413 return LiferayPortletMode.ABOUT;
5414 }
5415 else if (layoutType.hasModeConfigPortletId(portletId)) {
5416 return LiferayPortletMode.CONFIG;
5417 }
5418 else if (layoutType.hasModeEditPortletId(portletId)) {
5419 return PortletMode.EDIT;
5420 }
5421 else if (layoutType.hasModeEditDefaultsPortletId(portletId)) {
5422 return LiferayPortletMode.EDIT_DEFAULTS;
5423 }
5424 else if (layoutType.hasModeEditGuestPortletId(portletId)) {
5425 return LiferayPortletMode.EDIT_GUEST;
5426 }
5427 else if (layoutType.hasModeHelpPortletId(portletId)) {
5428 return PortletMode.HELP;
5429 }
5430 else if (layoutType.hasModePreviewPortletId(portletId)) {
5431 return LiferayPortletMode.PREVIEW;
5432 }
5433 else if (layoutType.hasModePrintPortletId(portletId)) {
5434 return LiferayPortletMode.PRINT;
5435 }
5436 else {
5437 return PortletMode.VIEW;
5438 }
5439 }
5440 else {
5441 boolean updateLayout = false;
5442
5443 if (portletMode.equals(LiferayPortletMode.ABOUT) &&
5444 !layoutType.hasModeAboutPortletId(portletId)) {
5445
5446 layoutType.addModeAboutPortletId(portletId);
5447
5448 updateLayout = true;
5449 }
5450 else if (portletMode.equals(LiferayPortletMode.CONFIG) &&
5451 !layoutType.hasModeConfigPortletId(portletId)) {
5452
5453 layoutType.addModeConfigPortletId(portletId);
5454
5455 updateLayout = true;
5456 }
5457 else if (portletMode.equals(PortletMode.EDIT) &&
5458 !layoutType.hasModeEditPortletId(portletId)) {
5459
5460 layoutType.addModeEditPortletId(portletId);
5461
5462 updateLayout = true;
5463 }
5464 else if (portletMode.equals(LiferayPortletMode.EDIT_DEFAULTS) &&
5465 !layoutType.hasModeEditDefaultsPortletId(portletId)) {
5466
5467 layoutType.addModeEditDefaultsPortletId(portletId);
5468
5469 updateLayout = true;
5470 }
5471 else if (portletMode.equals(LiferayPortletMode.EDIT_GUEST) &&
5472 !layoutType.hasModeEditGuestPortletId(portletId)) {
5473
5474 layoutType.addModeEditGuestPortletId(portletId);
5475
5476 updateLayout = true;
5477 }
5478 else if (portletMode.equals(PortletMode.HELP) &&
5479 !layoutType.hasModeHelpPortletId(portletId)) {
5480
5481 layoutType.addModeHelpPortletId(portletId);
5482
5483 updateLayout = true;
5484 }
5485 else if (portletMode.equals(LiferayPortletMode.PREVIEW) &&
5486 !layoutType.hasModePreviewPortletId(portletId)) {
5487
5488 layoutType.addModePreviewPortletId(portletId);
5489
5490 updateLayout = true;
5491 }
5492 else if (portletMode.equals(LiferayPortletMode.PRINT) &&
5493 !layoutType.hasModePrintPortletId(portletId)) {
5494
5495 layoutType.addModePrintPortletId(portletId);
5496
5497 updateLayout = true;
5498 }
5499 else if (portletMode.equals(PortletMode.VIEW) &&
5500 !layoutType.hasModeViewPortletId(portletId)) {
5501
5502 layoutType.removeModesPortletId(portletId);
5503
5504 updateLayout = true;
5505 }
5506
5507 if (updateLayout) {
5508 LayoutClone layoutClone = LayoutCloneFactory.getInstance();
5509
5510 if (layoutClone != null) {
5511 layoutClone.update(
5512 request, layout.getPlid(), layout.getTypeSettings());
5513 }
5514 }
5515
5516 return portletMode;
5517 }
5518 }
5519
5520 public String updateRedirect(
5521 String redirect, String oldPath, String newPath) {
5522
5523 if (Validator.isNotNull(redirect) && (oldPath != null) &&
5524 !oldPath.equals(newPath)) {
5525
5526 String queryString = HttpUtil.getQueryString(redirect);
5527
5528 String redirectParam = HttpUtil.getParameter(
5529 redirect, "redirect", false);
5530
5531 if (Validator.isNotNull(redirectParam)) {
5532 String newRedirectParam = StringUtil.replace(
5533 redirectParam, HttpUtil.encodeURL(oldPath),
5534 HttpUtil.encodeURL(newPath));
5535
5536 queryString = StringUtil.replace(
5537 queryString, redirectParam, newRedirectParam);
5538 }
5539
5540 String redirectPath = HttpUtil.getPath(redirect);
5541
5542 int pos = redirect.indexOf(redirectPath);
5543
5544 String prefix = redirect.substring(0, pos);
5545
5546 pos = redirectPath.lastIndexOf(oldPath);
5547
5548 if (pos != -1) {
5549 prefix += redirectPath.substring(0, pos);
5550
5551 String suffix = redirectPath.substring(pos + oldPath.length());
5552
5553 redirect = prefix + newPath + suffix;
5554 }
5555 else {
5556 redirect = prefix + redirectPath;
5557 }
5558
5559 if (Validator.isNotNull(queryString)) {
5560 redirect += StringPool.QUESTION + queryString;
5561 }
5562 }
5563
5564 return redirect;
5565 }
5566
5567 public WindowState updateWindowState(
5568 String portletId, User user, Layout layout, WindowState windowState,
5569 HttpServletRequest request) {
5570
5571 LayoutTypePortlet layoutType =
5572 (LayoutTypePortlet)layout.getLayoutType();
5573
5574 if ((windowState == null) || Validator.isNull(windowState.toString())) {
5575 if (layoutType.hasStateMaxPortletId(portletId)) {
5576 windowState = WindowState.MAXIMIZED;
5577 }
5578 else if (layoutType.hasStateMinPortletId(portletId)) {
5579 windowState = WindowState.MINIMIZED;
5580 }
5581 else {
5582 windowState = WindowState.NORMAL;
5583 }
5584 }
5585 else {
5586 boolean updateLayout = false;
5587
5588 if (windowState.equals(WindowState.MAXIMIZED) &&
5589 !layoutType.hasStateMaxPortletId(portletId)) {
5590
5591 layoutType.addStateMaxPortletId(portletId);
5592
5593 if (PropsValues.LAYOUT_REMEMBER_MAXIMIZED_WINDOW_STATE) {
5594 updateLayout = true;
5595 }
5596 }
5597 else if (windowState.equals(WindowState.MINIMIZED) &&
5598 !layoutType.hasStateMinPortletId(portletId)) {
5599
5600 layoutType.addStateMinPortletId(portletId);
5601
5602 updateLayout = true;
5603 }
5604 else if (windowState.equals(WindowState.NORMAL) &&
5605 !layoutType.hasStateNormalPortletId(portletId)) {
5606
5607 layoutType.removeStatesPortletId(portletId);
5608
5609 updateLayout = true;
5610 }
5611
5612 if (portletId.equals(PortletKeys.LAYOUTS_ADMIN) ||
5613 portletId.equals(PortletKeys.PORTLET_CONFIGURATION)) {
5614
5615 updateLayout = false;
5616 }
5617
5618 if (updateLayout) {
5619 LayoutClone layoutClone = LayoutCloneFactory.getInstance();
5620
5621 if (layoutClone != null) {
5622 layoutClone.update(
5623 request, layout.getPlid(), layout.getTypeSettings());
5624 }
5625 }
5626 }
5627
5628 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
5629 WebKeys.THEME_DISPLAY);
5630
5631 themeDisplay.setStateExclusive(
5632 windowState.equals(LiferayWindowState.EXCLUSIVE));
5633 themeDisplay.setStateMaximized(
5634 windowState.equals(WindowState.MAXIMIZED));
5635 themeDisplay.setStatePopUp(
5636 windowState.equals(LiferayWindowState.POP_UP));
5637
5638 if (themeDisplay.isStateMaximized() &&
5639 themeDisplay.isShowAddContentIcon()) {
5640
5641 themeDisplay.setShowAddContentIcon(false);
5642 }
5643 else if (!themeDisplay.isStateMaximized() &&
5644 !themeDisplay.isShowAddContentIcon() &&
5645 themeDisplay.isShowAddContentIconPermission()) {
5646
5647 themeDisplay.setShowAddContentIcon(true);
5648 }
5649
5650 request.setAttribute(WebKeys.WINDOW_STATE, windowState);
5651
5652 return windowState;
5653 }
5654
5655 protected void addDefaultResource(
5656 long companyId, Layout layout, Portlet portlet,
5657 boolean portletActions)
5658 throws PortalException, SystemException {
5659
5660 long groupId = getScopeGroupId(layout, portlet.getPortletId());
5661
5662 addDefaultResource(companyId, groupId, layout, portlet, portletActions);
5663 }
5664
5665 protected void addDefaultResource(
5666 long companyId, long groupId, Layout layout, Portlet portlet,
5667 boolean portletActions)
5668 throws PortalException, SystemException {
5669
5670 String rootPortletId = portlet.getRootPortletId();
5671
5672 String portletPrimaryKey = PortletPermissionUtil.getPrimaryKey(
5673 layout.getPlid(), portlet.getPortletId());
5674
5675 String name = null;
5676 String primaryKey = null;
5677
5678 if (portletActions) {
5679 name = rootPortletId;
5680 primaryKey = portletPrimaryKey;
5681 }
5682 else {
5683 name = ResourceActionsUtil.getPortletBaseResource(rootPortletId);
5684 primaryKey = String.valueOf(groupId);
5685 }
5686
5687 if (Validator.isNull(name)) {
5688 return;
5689 }
5690
5691 int count =
5692 ResourcePermissionLocalServiceUtil.getResourcePermissionsCount(
5693 companyId, name, ResourceConstants.SCOPE_INDIVIDUAL,
5694 primaryKey);
5695
5696 if (count == 0) {
5697 ResourceLocalServiceUtil.addResources(
5698 companyId, groupId, 0, name, primaryKey, portletActions, true,
5699 !layout.isPrivateLayout());
5700 }
5701 }
5702
5703 protected String buildI18NPath(Locale locale) {
5704 String languageId = LocaleUtil.toLanguageId(locale);
5705
5706 if (Validator.isNull(languageId)) {
5707 return null;
5708 }
5709
5710 if (LanguageUtil.isDuplicateLanguageCode(locale.getLanguage())) {
5711 Locale priorityLocale = LanguageUtil.getLocale(
5712 locale.getLanguage());
5713
5714 if (locale.equals(priorityLocale)) {
5715 languageId = locale.getLanguage();
5716 }
5717 }
5718 else {
5719 languageId = locale.getLanguage();
5720 }
5721
5722 return StringPool.SLASH.concat(languageId);
5723 }
5724
5725 protected long doGetPlidFromPortletId(
5726 long groupId, boolean privateLayout, String portletId)
5727 throws PortalException, SystemException {
5728
5729 long scopeGroupId = groupId;
5730
5731 try {
5732 Group group = GroupLocalServiceUtil.getGroup(groupId);
5733
5734 if (group.isLayout()) {
5735 Layout scopeLayout = LayoutLocalServiceUtil.getLayout(
5736 group.getClassPK());
5737
5738 groupId = scopeLayout.getGroupId();
5739 }
5740 }
5741 catch (Exception e) {
5742 }
5743
5744 long plid = LayoutConstants.DEFAULT_PLID;
5745
5746 List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
5747 groupId, privateLayout, LayoutConstants.TYPE_PORTLET);
5748
5749 for (Layout layout : layouts) {
5750 LayoutTypePortlet layoutTypePortlet =
5751 (LayoutTypePortlet)layout.getLayoutType();
5752
5753 if (layoutTypePortlet.hasPortletId(portletId)) {
5754 if (getScopeGroupId(layout, portletId) == scopeGroupId) {
5755 plid = layout.getPlid();
5756
5757 break;
5758 }
5759 }
5760 }
5761
5762 return plid;
5763 }
5764
5765 protected List<Portlet> filterControlPanelPortlets(
5766 Set<Portlet> portlets, String category, ThemeDisplay themeDisplay) {
5767
5768 Group group = themeDisplay.getScopeGroup();
5769
5770 List<Portlet> filteredPortlets = new ArrayList<Portlet>();
5771
5772 if (category.equals(PortletCategoryKeys.CONTENT) && group.isLayout()) {
5773 for (Portlet portlet : portlets) {
5774 if (portlet.isScopeable()) {
5775 filteredPortlets.add(portlet);
5776 }
5777 }
5778 }
5779 else {
5780 filteredPortlets.addAll(portlets);
5781 }
5782
5783 Iterator<Portlet> itr = filteredPortlets.iterator();
5784
5785 while (itr.hasNext()) {
5786 Portlet portlet = itr.next();
5787
5788 try {
5789 ControlPanelEntry controlPanelEntry =
5790 portlet.getControlPanelEntryInstance();
5791
5792 if (controlPanelEntry == null) {
5793 controlPanelEntry =
5794 DefaultControlPanelEntryFactory.getInstance();
5795 }
5796
5797 if (!controlPanelEntry.isVisible(
5798 portlet, category, themeDisplay)) {
5799
5800 itr.remove();
5801 }
5802 }
5803 catch (Exception e) {
5804 _log.error(e, e);
5805
5806 itr.remove();
5807 }
5808 }
5809
5810 return filteredPortlets;
5811 }
5812
5813 protected long getDefaultScopeGroupId(long companyId)
5814 throws PortalException, SystemException {
5815
5816 long doAsGroupId = 0;
5817
5818 Collection<Portlet> portlets = getControlPanelPortlets(
5819 companyId, PortletCategoryKeys.CONTENT);
5820
5821 List<Group> groups = GroupServiceUtil.getManageableSites(portlets, 1);
5822
5823 if (!groups.isEmpty()) {
5824 Group group = groups.get(0);
5825
5826 doAsGroupId = group.getGroupId();
5827 }
5828 else {
5829 Group guestGroup = GroupLocalServiceUtil.fetchGroup(
5830 companyId, GroupConstants.GUEST);
5831
5832 if (guestGroup != null) {
5833 doAsGroupId = guestGroup.getGroupId();
5834 }
5835 }
5836
5837 return doAsGroupId;
5838 }
5839
5840 protected long getDoAsUserId(
5841 HttpServletRequest request, String doAsUserIdString,
5842 boolean alwaysAllowDoAsUser)
5843 throws Exception {
5844
5845 if (Validator.isNull(doAsUserIdString)) {
5846 return 0;
5847 }
5848
5849 long doAsUserId = 0;
5850
5851 try {
5852 Company company = getCompany(request);
5853
5854 doAsUserId = GetterUtil.getLong(
5855 Encryptor.decrypt(company.getKeyObj(), doAsUserIdString));
5856 }
5857 catch (Exception e) {
5858 if (_log.isWarnEnabled()) {
5859 _log.warn(
5860 "Unable to impersonate " + doAsUserIdString +
5861 " because the string cannot be decrypted");
5862 }
5863
5864 return 0;
5865 }
5866
5867 if (_log.isDebugEnabled()) {
5868 if (alwaysAllowDoAsUser) {
5869 _log.debug(
5870 "doAsUserId path or Struts action is always allowed");
5871 }
5872 else {
5873 _log.debug(
5874 "doAsUserId path is Struts action not always allowed");
5875 }
5876 }
5877
5878 if (alwaysAllowDoAsUser) {
5879 request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
5880
5881 return doAsUserId;
5882 }
5883
5884 HttpSession session = request.getSession();
5885
5886 Long realUserIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
5887
5888 if (realUserIdObj == null) {
5889 return 0;
5890 }
5891
5892 User doAsUser = UserLocalServiceUtil.getUserById(doAsUserId);
5893
5894 long[] organizationIds = doAsUser.getOrganizationIds();
5895
5896 User realUser = UserLocalServiceUtil.getUserById(
5897 realUserIdObj.longValue());
5898
5899 PermissionChecker permissionChecker =
5900 PermissionCheckerFactoryUtil.create(realUser);
5901
5902 if (doAsUser.isDefaultUser() ||
5903 UserPermissionUtil.contains(
5904 permissionChecker, doAsUserId, organizationIds,
5905 ActionKeys.IMPERSONATE)) {
5906
5907 request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
5908
5909 return doAsUserId;
5910 }
5911 else {
5912 _log.error(
5913 "User " + realUserIdObj + " does not have the permission " +
5914 "to impersonate " + doAsUserId);
5915
5916 return 0;
5917 }
5918 }
5919
5920 protected String getGroupFriendlyURL(
5921 Group group, boolean privateLayoutSet, ThemeDisplay themeDisplay,
5922 boolean canonicalURL)
5923 throws PortalException, SystemException {
5924
5925 LayoutSet layoutSet = LayoutSetLocalServiceUtil.getLayoutSet(
5926 group.getGroupId(), privateLayoutSet);
5927
5928 String portalURL = StringPool.BLANK;
5929
5930 if (canonicalURL || !themeDisplay.getServerName().equals(_LOCALHOST)) {
5931 String virtualHostname = layoutSet.getVirtualHostname();
5932
5933 if (Validator.isNull(virtualHostname) &&
5934 Validator.isNotNull(
5935 PropsValues.VIRTUAL_HOSTS_DEFAULT_SITE_NAME) &&
5936 !layoutSet.isPrivateLayout()) {
5937
5938 try {
5939 Group defaultGroup = GroupLocalServiceUtil.getGroup(
5940 themeDisplay.getCompanyId(),
5941 PropsValues.VIRTUAL_HOSTS_DEFAULT_SITE_NAME);
5942
5943 if (layoutSet.getGroupId() == defaultGroup.getGroupId()) {
5944 Company company = themeDisplay.getCompany();
5945
5946 virtualHostname = company.getVirtualHostname();
5947 }
5948 }
5949 catch (Exception e) {
5950 _log.error(e, e);
5951 }
5952 }
5953
5954 if (Validator.isNotNull(virtualHostname) &&
5955 (canonicalURL ||
5956 !virtualHostname.equalsIgnoreCase(_LOCALHOST))) {
5957
5958 virtualHostname = getPortalURL(
5959 virtualHostname, themeDisplay.getServerPort(),
5960 themeDisplay.isSecure());
5961
5962 String portalDomain = HttpUtil.getDomain(
5963 themeDisplay.getPortalURL());
5964
5965 if (canonicalURL || virtualHostname.contains(portalDomain)) {
5966 String path = StringPool.BLANK;
5967
5968 if (themeDisplay.isWidget()) {
5969 path = PropsValues.WIDGET_SERVLET_MAPPING;
5970 }
5971
5972 if (themeDisplay.isI18n() && !canonicalURL) {
5973 path = themeDisplay.getI18nPath();
5974 }
5975
5976 return virtualHostname.concat(_pathContext).concat(path);
5977 }
5978 }
5979 else {
5980 Layout curLayout = themeDisplay.getLayout();
5981
5982 LayoutSet curLayoutSet = curLayout.getLayoutSet();
5983
5984 if (canonicalURL ||
5985 ((layoutSet.getLayoutSetId() !=
5986 curLayoutSet.getLayoutSetId()) &&
5987 (group.getClassPK() != themeDisplay.getUserId()))) {
5988
5989 if (group.isControlPanel()) {
5990 virtualHostname = themeDisplay.getServerName();
5991
5992 if (Validator.isNull(virtualHostname) ||
5993 virtualHostname.equalsIgnoreCase(_LOCALHOST)) {
5994
5995 virtualHostname = curLayoutSet.getVirtualHostname();
5996 }
5997 }
5998
5999 if (Validator.isNull(virtualHostname) ||
6000 virtualHostname.equalsIgnoreCase(_LOCALHOST)) {
6001
6002 Company company = themeDisplay.getCompany();
6003
6004 virtualHostname = company.getVirtualHostname();
6005 }
6006
6007 if (canonicalURL ||
6008 !virtualHostname.equalsIgnoreCase(_LOCALHOST)) {
6009
6010 portalURL = getPortalURL(
6011 virtualHostname, themeDisplay.getServerPort(),
6012 themeDisplay.isSecure());
6013 }
6014 }
6015 }
6016 }
6017
6018 String friendlyURL = null;
6019
6020 if (privateLayoutSet) {
6021 if (group.isUser()) {
6022 friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
6023 }
6024 else {
6025 friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
6026 }
6027 }
6028 else {
6029 friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
6030 }
6031
6032 StringBundler sb = new StringBundler(6);
6033
6034 sb.append(portalURL);
6035 sb.append(_pathContext);
6036
6037 if (themeDisplay.isI18n() && !canonicalURL) {
6038 sb.append(themeDisplay.getI18nPath());
6039 }
6040
6041 if (themeDisplay.isWidget()) {
6042 sb.append(PropsValues.WIDGET_SERVLET_MAPPING);
6043 }
6044
6045 sb.append(friendlyURL);
6046 sb.append(group.getFriendlyURL());
6047
6048 return sb.toString();
6049 }
6050
6051 protected String getPortletParam(HttpServletRequest request, String name) {
6052 String portletId = ParamUtil.getString(request, "p_p_id");
6053
6054 if (Validator.isNull(portletId)) {
6055 return StringPool.BLANK;
6056 }
6057
6058 String value = null;
6059
6060 int valueCount = 0;
6061
6062 String keyName = StringPool.UNDERLINE.concat(name);
6063
6064 Map<String, String[]> parameterMap = request.getParameterMap();
6065
6066 for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
6067 String parameterName = entry.getKey();
6068
6069 int pos = parameterName.indexOf(keyName);
6070
6071 if (pos == -1) {
6072 continue;
6073 }
6074
6075 valueCount++;
6076
6077
6078
6079 if (valueCount > 1) {
6080 return StringPool.BLANK;
6081 }
6082
6083 String[] parameterValues = entry.getValue();
6084
6085 if ((parameterValues == null) || (parameterValues.length == 0) ||
6086 Validator.isNull(parameterValues[0])) {
6087
6088 continue;
6089 }
6090
6091
6092
6093 String portletId1 = parameterName.substring(1, pos);
6094
6095 if (portletId.equals(portletId1)) {
6096 value = parameterValues[0];
6097 }
6098 }
6099
6100 if (value == null) {
6101 value = StringPool.BLANK;
6102 }
6103
6104 return value;
6105 }
6106
6107 protected String getServletURL(
6108 Portlet portlet, String servletPath, ThemeDisplay themeDisplay)
6109 throws PortalException, SystemException {
6110
6111 Layout layout = themeDisplay.getLayout();
6112
6113 StringBundler sb = new StringBundler();
6114
6115 sb.append(themeDisplay.getPortalURL());
6116
6117 if (Validator.isNotNull(_pathContext)) {
6118 sb.append(_pathContext);
6119 }
6120
6121 if (themeDisplay.isI18n()) {
6122 sb.append(themeDisplay.getI18nPath());
6123 }
6124
6125 sb.append(servletPath);
6126
6127 Group group = layout.getGroup();
6128
6129 if (layout.isPrivateLayout()) {
6130 if (group.isUser()) {
6131 sb.append(_PRIVATE_USER_SERVLET_MAPPING);
6132 }
6133 else {
6134 sb.append(_PRIVATE_GROUP_SERVLET_MAPPING);
6135 }
6136 }
6137 else {
6138 sb.append(_PUBLIC_GROUP_SERVLET_MAPPING);
6139 }
6140
6141 sb.append(group.getFriendlyURL());
6142 sb.append(layout.getFriendlyURL());
6143
6144 sb.append(FRIENDLY_URL_SEPARATOR);
6145
6146 FriendlyURLMapper friendlyURLMapper =
6147 portlet.getFriendlyURLMapperInstance();
6148
6149 if ((friendlyURLMapper != null) && !portlet.isInstanceable()) {
6150 sb.append(friendlyURLMapper.getMapping());
6151 }
6152 else {
6153 sb.append(portlet.getPortletId());
6154 }
6155
6156 return sb.toString();
6157 }
6158
6159 protected boolean isAlwaysAllowDoAsUser(HttpServletRequest request)
6160 throws Exception {
6161
6162 String ticketKey = ParamUtil.getString(request, "ticketKey");
6163
6164 if (Validator.isNull(ticketKey)) {
6165 return false;
6166 }
6167
6168 Ticket ticket = TicketLocalServiceUtil.fetchTicket(ticketKey);
6169
6170 if ((ticket == null) ||
6171 (ticket.getType() != TicketConstants.TYPE_IMPERSONATE)) {
6172
6173 return false;
6174 }
6175
6176 String className = ticket.getClassName();
6177
6178 if (!className.equals(User.class.getName())) {
6179 return false;
6180 }
6181
6182 long doAsUserId = 0;
6183
6184 try {
6185 Company company = getCompany(request);
6186
6187 String doAsUserIdString = ParamUtil.getString(
6188 request, "doAsUserId");
6189
6190 if (Validator.isNotNull(doAsUserIdString)) {
6191 doAsUserId = GetterUtil.getLong(
6192 Encryptor.decrypt(company.getKeyObj(), doAsUserIdString));
6193 }
6194 }
6195 catch (Exception e) {
6196 return false;
6197 }
6198
6199 if (ticket.getClassPK() != doAsUserId) {
6200 return false;
6201 }
6202
6203 if (ticket.isExpired()) {
6204 TicketLocalServiceUtil.deleteTicket(ticket);
6205
6206 return false;
6207 }
6208
6209 Date expirationDate = new Date(
6210 System.currentTimeMillis() +
6211 PropsValues.SESSION_TIMEOUT * Time.MINUTE);
6212
6213 ticket.setExpirationDate(expirationDate);
6214
6215 TicketLocalServiceUtil.updateTicket(ticket);
6216
6217 return true;
6218 }
6219
6220 protected boolean isPanelSelectedPortlet(
6221 ThemeDisplay themeDisplay, String portletId) {
6222
6223 Layout layout = themeDisplay.getLayout();
6224
6225 String panelSelectedPortlets = layout.getTypeSettingsProperty(
6226 "panelSelectedPortlets");
6227
6228 if (Validator.isNotNull(panelSelectedPortlets)) {
6229 String[] panelSelectedPortletsArray = StringUtil.split(
6230 panelSelectedPortlets);
6231
6232 return ArrayUtil.contains(panelSelectedPortletsArray, portletId);
6233 }
6234
6235 return false;
6236 }
6237
6238 protected void notifyPortalPortEventListeners(int portalPort) {
6239 for (PortalPortEventListener portalPortEventListener :
6240 _portalPortEventListeners) {
6241
6242 portalPortEventListener.portalPortConfigured(portalPort);
6243 }
6244 }
6245
6246 protected String removeRedirectParameter(String url) {
6247 String queryString = HttpUtil.getQueryString(url);
6248
6249 Map<String, String[]> parameterMap = HttpUtil.getParameterMap(
6250 queryString);
6251
6252 for (String parameter : parameterMap.keySet()) {
6253 if (parameter.endsWith("redirect")) {
6254 url = HttpUtil.removeParameter(url, parameter);
6255 }
6256 }
6257
6258 return url;
6259 }
6260
6261 private static final String _J_SECURITY_CHECK = "j_security_check";
6262
6263 private static final String _JSESSIONID = ";jsessionid=";
6264
6265 private static final String _LOCALHOST = "localhost";
6266
6267 private static final String _PRIVATE_GROUP_SERVLET_MAPPING =
6268 PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_GROUP_SERVLET_MAPPING;
6269
6270 private static final String _PRIVATE_USER_SERVLET_MAPPING =
6271 PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_USER_SERVLET_MAPPING;
6272
6273 private static final String _PUBLIC_GROUP_SERVLET_MAPPING =
6274 PropsValues.LAYOUT_FRIENDLY_URL_PUBLIC_SERVLET_MAPPING;
6275
6276 private static Log _log = LogFactoryUtil.getLog(PortalImpl.class);
6277
6278 private static Log _logWebServerServlet = LogFactoryUtil.getLog(
6279 WebServerServlet.class);
6280
6281 private static Map<Long, String> _cdnHostHttpMap =
6282 new ConcurrentHashMap<Long, String>();
6283 private static Map<Long, String> _cdnHostHttpsMap =
6284 new ConcurrentHashMap<Long, String>();
6285 private static MethodHandler _resetCDNHostsMethodHandler =
6286 new MethodHandler(
6287 new MethodKey(PortalUtil.class.getName(), "resetCDNHosts"));
6288 private static Date _upTime = new Date();
6289
6290 private String[] _allSystemGroups;
6291 private String[] _allSystemOrganizationRoles;
6292 private String[] _allSystemRoles;
6293 private String[] _allSystemSiteRoles;
6294 private Set<String> _authTokenIgnoreActions;
6295 private Set<String> _authTokenIgnorePortlets;
6296 private Pattern _bannedResourceIdPattern = Pattern.compile(
6297 PropsValues.PORTLET_RESOURCE_ID_BANNED_PATHS_REGEXP,
6298 Pattern.CASE_INSENSITIVE);
6299 private String _computerAddress;
6300 private String _computerName;
6301 private String[] _customSqlKeys;
6302 private String[] _customSqlValues;
6303 private String _pathContext;
6304 private String _pathFriendlyURLPrivateGroup;
6305 private String _pathFriendlyURLPrivateUser;
6306 private String _pathFriendlyURLPublic;
6307 private String _pathImage;
6308 private String _pathMain;
6309 private String _pathProxy;
6310 private Map<String, Long> _plidToPortletIdMap =
6311 new ConcurrentHashMap<String, Long>();
6312 private final AtomicInteger _portalPort = new AtomicInteger(-1);
6313 private List<PortalPortEventListener> _portalPortEventListeners =
6314 new ArrayList<PortalPortEventListener>();
6315 private Set<String> _portletAddDefaultResourceCheckWhitelist;
6316 private Set<String> _portletAddDefaultResourceCheckWhitelistActions;
6317 private Set<String> _reservedParams;
6318 private final AtomicInteger _securePortalPort = new AtomicInteger(-1);
6319 private String[] _sortedSystemGroups;
6320 private String[] _sortedSystemOrganizationRoles;
6321 private String[] _sortedSystemRoles;
6322 private String[] _sortedSystemSiteRoles;
6323
6324 }