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