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