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