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