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