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