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