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