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