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