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