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