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