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