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