001
014
015 package com.liferay.portal.util;
016
017 import com.liferay.portal.RSSFeedException;
018 import com.liferay.portal.comment.action.EditDiscussionStrutsAction;
019 import com.liferay.portal.comment.action.GetCommentsStrutsAction;
020 import com.liferay.portal.dao.orm.common.SQLTransformer;
021 import com.liferay.portal.events.StartupHelperUtil;
022 import com.liferay.portal.exception.ImageTypeException;
023 import com.liferay.portal.exception.NoSuchGroupException;
024 import com.liferay.portal.exception.NoSuchImageException;
025 import com.liferay.portal.exception.NoSuchLayoutException;
026 import com.liferay.portal.exception.NoSuchUserException;
027 import com.liferay.portal.kernel.bean.BeanPropertiesUtil;
028 import com.liferay.portal.kernel.cluster.ClusterExecutorUtil;
029 import com.liferay.portal.kernel.cluster.ClusterInvokeThreadLocal;
030 import com.liferay.portal.kernel.cluster.ClusterRequest;
031 import com.liferay.portal.kernel.concurrent.ConcurrentHashSet;
032 import com.liferay.portal.kernel.dao.db.DB;
033 import com.liferay.portal.kernel.dao.db.DBManagerUtil;
034 import com.liferay.portal.kernel.dao.jdbc.DataAccess;
035 import com.liferay.portal.kernel.dao.orm.QueryUtil;
036 import com.liferay.portal.kernel.exception.PortalException;
037 import com.liferay.portal.kernel.exception.SystemException;
038 import com.liferay.portal.kernel.image.ImageBag;
039 import com.liferay.portal.kernel.image.ImageToolUtil;
040 import com.liferay.portal.kernel.language.LanguageUtil;
041 import com.liferay.portal.kernel.log.Log;
042 import com.liferay.portal.kernel.log.LogFactoryUtil;
043 import com.liferay.portal.kernel.portlet.FriendlyURLMapper;
044 import com.liferay.portal.kernel.portlet.FriendlyURLMapperThreadLocal;
045 import com.liferay.portal.kernel.portlet.FriendlyURLResolver;
046 import com.liferay.portal.kernel.portlet.FriendlyURLResolverRegistryUtil;
047 import com.liferay.portal.kernel.portlet.LiferayPortletConfig;
048 import com.liferay.portal.kernel.portlet.LiferayPortletMode;
049 import com.liferay.portal.kernel.portlet.LiferayPortletRequest;
050 import com.liferay.portal.kernel.portlet.LiferayPortletResponse;
051 import com.liferay.portal.kernel.portlet.LiferayPortletURL;
052 import com.liferay.portal.kernel.portlet.LiferayWindowState;
053 import com.liferay.portal.kernel.portlet.PortletBag;
054 import com.liferay.portal.kernel.portlet.PortletBagPool;
055 import com.liferay.portal.kernel.security.auth.AlwaysAllowDoAsUser;
056 import com.liferay.portal.kernel.security.auth.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.exception.ImageSizeException;
203 import com.liferay.portlet.documentlibrary.model.DLFileEntry;
204 import com.liferay.portlet.documentlibrary.model.DLFolder;
205 import com.liferay.portlet.expando.exception.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.social.model.SocialRelationConstants;
211 import com.liferay.portlet.social.util.FacebookUtil;
212 import com.liferay.registry.Registry;
213 import com.liferay.registry.RegistryUtil;
214 import com.liferay.registry.ServiceReference;
215 import com.liferay.registry.ServiceTracker;
216 import com.liferay.registry.ServiceTrackerCustomizer;
217 import com.liferay.sites.kernel.util.Sites;
218 import com.liferay.sites.kernel.util.SitesUtil;
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.isWarnEnabled()) {
882 _log.warn("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.isWarnEnabled()) {
911 _log.warn("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 getLayoutSetDisplayURL(
2955 LayoutSet layoutSet, boolean secureConnection)
2956 throws PortalException {
2957
2958 Company company = CompanyLocalServiceUtil.getCompany(
2959 layoutSet.getCompanyId());
2960 int portalPort = getPortalServerPort(secureConnection);
2961
2962 String portalURL = getPortalURL(
2963 company.getVirtualHostname(), portalPort, secureConnection);
2964
2965 String virtualHostname = getVirtualHostname(layoutSet);
2966
2967 if (Validator.isNotNull(virtualHostname) &&
2968 !StringUtil.equalsIgnoreCase(virtualHostname, "localhost")) {
2969
2970 String portalDomain = HttpUtil.getDomain(portalURL);
2971
2972 virtualHostname = getCanonicalDomain(virtualHostname, portalDomain);
2973
2974 virtualHostname = getPortalURL(
2975 virtualHostname, portalPort, secureConnection);
2976
2977 if (virtualHostname.contains(portalDomain)) {
2978 return virtualHostname.concat(getPathContext());
2979 }
2980 }
2981
2982 StringBundler sb = new StringBundler(4);
2983
2984 sb.append(portalURL);
2985 sb.append(getPathContext());
2986
2987 Group group = layoutSet.getGroup();
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 sb.append(friendlyURL);
3004
3005 sb.append(group.getFriendlyURL());
3006
3007 return sb.toString();
3008 }
3009
3010 @Override
3011 public String getLayoutSetFriendlyURL(
3012 LayoutSet layoutSet, ThemeDisplay themeDisplay)
3013 throws PortalException {
3014
3015 String virtualHostname = getVirtualHostname(layoutSet);
3016
3017 if (Validator.isNotNull(virtualHostname) &&
3018 !StringUtil.equalsIgnoreCase(virtualHostname, _LOCALHOST)) {
3019
3020 String portalURL = getPortalURL(
3021 virtualHostname, themeDisplay.getServerPort(),
3022 themeDisplay.isSecure());
3023
3024
3025
3026
3027 long curLayoutSetId =
3028 themeDisplay.getLayout().getLayoutSet().getLayoutSetId();
3029
3030 if ((layoutSet.getLayoutSetId() != curLayoutSetId) ||
3031 portalURL.startsWith(themeDisplay.getURLPortal())) {
3032
3033 String layoutSetFriendlyURL = portalURL + _pathContext;
3034
3035 if (themeDisplay.isI18n()) {
3036 layoutSetFriendlyURL += themeDisplay.getI18nPath();
3037 }
3038
3039 return addPreservedParameters(
3040 themeDisplay, layoutSetFriendlyURL);
3041 }
3042 }
3043
3044 Group group = GroupLocalServiceUtil.getGroup(layoutSet.getGroupId());
3045
3046 String friendlyURL = null;
3047
3048 if (layoutSet.isPrivateLayout()) {
3049 if (group.isUser()) {
3050 friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
3051 }
3052 else {
3053 friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
3054 }
3055 }
3056 else {
3057 friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
3058 }
3059
3060 if (themeDisplay.isI18n()) {
3061 friendlyURL = themeDisplay.getI18nPath() + friendlyURL;
3062 }
3063
3064 String layoutSetFriendlyURL =
3065 _pathContext + friendlyURL + group.getFriendlyURL();
3066
3067 return addPreservedParameters(themeDisplay, layoutSetFriendlyURL);
3068 }
3069
3070 @Override
3071 public String getLayoutTarget(Layout layout) {
3072 UnicodeProperties typeSettingsProps =
3073 layout.getTypeSettingsProperties();
3074
3075 String target = typeSettingsProps.getProperty("target");
3076
3077 if (Validator.isNull(target)) {
3078 target = StringPool.BLANK;
3079 }
3080 else {
3081 target = "target=\"" + HtmlUtil.escapeAttribute(target) + "\"";
3082 }
3083
3084 return target;
3085 }
3086
3087 @Override
3088 public String getLayoutURL(Layout layout, ThemeDisplay themeDisplay)
3089 throws PortalException {
3090
3091 return getLayoutURL(layout, themeDisplay, true);
3092 }
3093
3094 @Override
3095 public String getLayoutURL(
3096 Layout layout, ThemeDisplay themeDisplay, boolean doAsUser)
3097 throws PortalException {
3098
3099 if (layout == null) {
3100 return themeDisplay.getPathMain() + PATH_PORTAL_LAYOUT;
3101 }
3102
3103 if (!layout.isTypeURL()) {
3104 String layoutFriendlyURL = getLayoutFriendlyURL(
3105 layout, themeDisplay);
3106
3107 if (Validator.isNotNull(layoutFriendlyURL)) {
3108 layoutFriendlyURL = addPreservedParameters(
3109 themeDisplay, layout, layoutFriendlyURL, doAsUser);
3110
3111 return layoutFriendlyURL;
3112 }
3113 }
3114
3115 String layoutURL = getLayoutActualURL(layout);
3116
3117 layoutURL = addPreservedParameters(
3118 themeDisplay, layout, layoutURL, doAsUser);
3119
3120 return layoutURL;
3121 }
3122
3123 @Override
3124 public String getLayoutURL(
3125 Layout layout, ThemeDisplay themeDisplay, Locale locale)
3126 throws PortalException {
3127
3128 String i18nLanguageId = themeDisplay.getI18nLanguageId();
3129 String i18nPath = themeDisplay.getI18nPath();
3130 Locale originalLocale = themeDisplay.getLocale();
3131
3132 try {
3133 setThemeDisplayI18n(themeDisplay, locale);
3134
3135 return getLayoutURL(layout, themeDisplay, true);
3136 }
3137 finally {
3138 resetThemeDisplayI18n(
3139 themeDisplay, i18nLanguageId, i18nPath, originalLocale);
3140 }
3141 }
3142
3143 @Override
3144 public String getLayoutURL(ThemeDisplay themeDisplay)
3145 throws PortalException {
3146
3147 return getLayoutURL(themeDisplay.getLayout(), themeDisplay);
3148 }
3149
3150 @Override
3151 public LiferayPortletRequest getLiferayPortletRequest(
3152 PortletRequest portletRequest) {
3153
3154 if (portletRequest instanceof LiferayPortletRequest) {
3155 return (LiferayPortletRequest)portletRequest;
3156 }
3157
3158 PortletRequestImpl portletRequestImpl =
3159 PortletRequestImpl.getPortletRequestImpl(portletRequest);
3160
3161 return DoPrivilegedUtil.wrapWhenActive(portletRequestImpl);
3162 }
3163
3164 @Override
3165 public LiferayPortletResponse getLiferayPortletResponse(
3166 PortletResponse portletResponse) {
3167
3168 if (portletResponse instanceof LiferayPortletResponse) {
3169 return (LiferayPortletResponse)portletResponse;
3170 }
3171
3172 PortletResponseImpl portletResponseImpl =
3173 PortletResponseImpl.getPortletResponseImpl(portletResponse);
3174
3175 return DoPrivilegedUtil.wrapWhenActive(portletResponseImpl);
3176 }
3177
3178 @Override
3179 public Locale getLocale(HttpServletRequest request) {
3180 return getLocale(request, null, false);
3181 }
3182
3183 @Override
3184 public Locale getLocale(
3185 HttpServletRequest request, HttpServletResponse response,
3186 boolean initialize) {
3187
3188 User user = null;
3189
3190 if (initialize) {
3191 try {
3192 user = initUser(request);
3193 }
3194 catch (NoSuchUserException nsue) {
3195 return null;
3196 }
3197 catch (Exception e) {
3198 }
3199 }
3200
3201 Locale locale = null;
3202
3203 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
3204 WebKeys.THEME_DISPLAY);
3205
3206 if (themeDisplay != null) {
3207 locale = themeDisplay.getLocale();
3208
3209 if (LanguageUtil.isAvailableLocale(
3210 themeDisplay.getSiteGroupId(), locale)) {
3211
3212 return locale;
3213 }
3214 }
3215
3216 long groupId = 0;
3217
3218 Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
3219
3220 if ((layout != null) && !layout.isTypeControlPanel()) {
3221 try {
3222 long scopeGroupId = getScopeGroupId(request);
3223
3224 groupId = getSiteGroupId(scopeGroupId);
3225 }
3226 catch (Exception e) {
3227 }
3228 }
3229
3230 String i18nLanguageId = (String)request.getAttribute(
3231 WebKeys.I18N_LANGUAGE_ID);
3232
3233 if (Validator.isNotNull(i18nLanguageId)) {
3234 locale = LocaleUtil.fromLanguageId(i18nLanguageId);
3235
3236 if (LanguageUtil.isAvailableLocale(groupId, locale)) {
3237 return locale;
3238 }
3239 else if (groupId > 0) {
3240 boolean inheritLocales = true;
3241
3242 try {
3243 inheritLocales = LanguageUtil.isInheritLocales(groupId);
3244 }
3245 catch (PortalException pe) {
3246 _log.error(pe);
3247 }
3248
3249 if (!inheritLocales) {
3250 String i18nLanguageCode = (String)request.getAttribute(
3251 WebKeys.I18N_LANGUAGE_CODE);
3252
3253 locale = LanguageUtil.getLocale(groupId, i18nLanguageCode);
3254
3255 if (LanguageUtil.isAvailableLocale(groupId, locale)) {
3256 return locale;
3257 }
3258 }
3259 }
3260 }
3261
3262 String doAsUserLanguageId = ParamUtil.getString(
3263 request, "doAsUserLanguageId");
3264
3265 if (Validator.isNotNull(doAsUserLanguageId)) {
3266 locale = LocaleUtil.fromLanguageId(doAsUserLanguageId);
3267
3268 if (LanguageUtil.isAvailableLocale(groupId, locale)) {
3269 return locale;
3270 }
3271 }
3272
3273 HttpSession session = request.getSession(false);
3274
3275 if ((session != null) &&
3276 session.getAttribute(Globals.LOCALE_KEY) != null) {
3277
3278 locale = (Locale)session.getAttribute(Globals.LOCALE_KEY);
3279
3280 if (LanguageUtil.isAvailableLocale(groupId, locale)) {
3281 return locale;
3282 }
3283 }
3284
3285
3286
3287 if (user == null) {
3288 try {
3289 user = getUser(request);
3290 }
3291 catch (Exception e) {
3292 }
3293 }
3294
3295 if ((user != null) && !user.isDefaultUser()) {
3296 Locale userLocale = getAvailableLocale(groupId, user.getLocale());
3297
3298 if (LanguageUtil.isAvailableLocale(groupId, userLocale)) {
3299 if (initialize) {
3300 setLocale(request, response, userLocale);
3301 }
3302
3303 return userLocale;
3304 }
3305 }
3306
3307
3308
3309 String languageId = CookieKeys.getCookie(
3310 request, CookieKeys.GUEST_LANGUAGE_ID, false);
3311
3312 if (Validator.isNotNull(languageId)) {
3313 Locale cookieLocale = getAvailableLocale(
3314 groupId, LocaleUtil.fromLanguageId(languageId));
3315
3316 if (LanguageUtil.isAvailableLocale(groupId, cookieLocale)) {
3317 if (initialize) {
3318 setLocale(request, response, cookieLocale);
3319 }
3320
3321 return cookieLocale;
3322 }
3323 }
3324
3325
3326
3327 if (PropsValues.LOCALE_DEFAULT_REQUEST) {
3328 Enumeration<Locale> locales = request.getLocales();
3329
3330 while (locales.hasMoreElements()) {
3331 Locale requestLocale = getAvailableLocale(
3332 groupId, locales.nextElement());
3333
3334 if (LanguageUtil.isAvailableLocale(groupId, requestLocale)) {
3335 if (initialize) {
3336 setLocale(request, response, requestLocale);
3337 }
3338
3339 return requestLocale;
3340 }
3341 }
3342 }
3343
3344
3345
3346 if (groupId > 0) {
3347 try {
3348 Group group = GroupLocalServiceUtil.getGroup(groupId);
3349
3350 UnicodeProperties typeSettingsProperties =
3351 group.getTypeSettingsProperties();
3352
3353 String defaultLanguageId = typeSettingsProperties.getProperty(
3354 "languageId");
3355
3356 if (Validator.isNotNull(defaultLanguageId)) {
3357 locale = LocaleUtil.fromLanguageId(defaultLanguageId);
3358
3359 if (LanguageUtil.isAvailableLocale(groupId, locale)) {
3360 if (initialize) {
3361 setLocale(request, response, locale);
3362 }
3363
3364 return locale;
3365 }
3366 }
3367 }
3368 catch (Exception e) {
3369 }
3370 }
3371
3372
3373
3374 Company company = null;
3375
3376 try {
3377 company = getCompany(request);
3378 }
3379 catch (Exception e) {
3380 }
3381
3382 if (company == null) {
3383 return null;
3384 }
3385
3386 User defaultUser = null;
3387
3388 try {
3389 defaultUser = company.getDefaultUser();
3390 }
3391 catch (Exception e) {
3392 }
3393
3394 if (defaultUser == null) {
3395 return null;
3396 }
3397
3398 Locale defaultUserLocale = getAvailableLocale(
3399 groupId, defaultUser.getLocale());
3400
3401 if (LanguageUtil.isAvailableLocale(groupId, defaultUserLocale)) {
3402 if (initialize) {
3403 setLocale(request, response, defaultUserLocale);
3404 }
3405
3406 return defaultUserLocale;
3407 }
3408
3409 try {
3410 if (themeDisplay != null) {
3411 return themeDisplay.getSiteDefaultLocale();
3412 }
3413 }
3414 catch (Exception e) {
3415 }
3416
3417 try {
3418 return getSiteDefaultLocale(groupId);
3419 }
3420 catch (Exception e) {
3421 return LocaleUtil.getDefault();
3422 }
3423 }
3424
3425 @Override
3426 public Locale getLocale(PortletRequest portletRequest) {
3427 return getLocale(getHttpServletRequest(portletRequest));
3428 }
3429
3430 @Override
3431 public String getLocalizedFriendlyURL(
3432 HttpServletRequest request, Layout layout, Locale locale,
3433 Locale originalLocale)
3434 throws Exception {
3435
3436 String contextPath = getPathContext();
3437
3438 String requestURI = request.getRequestURI();
3439
3440 if (Validator.isNotNull(contextPath) &&
3441 requestURI.contains(contextPath)) {
3442
3443 requestURI = requestURI.substring(contextPath.length());
3444 }
3445
3446 requestURI = StringUtil.replace(
3447 requestURI, StringPool.DOUBLE_SLASH, StringPool.SLASH);
3448
3449 String path = request.getPathInfo();
3450
3451 int x = path.indexOf(CharPool.SLASH, 1);
3452
3453 String layoutFriendlyURL = null;
3454
3455 if (originalLocale == null) {
3456 if ((x != -1) && ((x + 1) != path.length())) {
3457 layoutFriendlyURL = path.substring(x);
3458 }
3459
3460 int y = layoutFriendlyURL.indexOf(
3461 VirtualLayoutConstants.CANONICAL_URL_SEPARATOR);
3462
3463 if (y != -1) {
3464 y = layoutFriendlyURL.indexOf(CharPool.SLASH, 3);
3465
3466 if ((y != -1) && ((y + 1) != layoutFriendlyURL.length())) {
3467 layoutFriendlyURL = layoutFriendlyURL.substring(y);
3468 }
3469 }
3470
3471 y = layoutFriendlyURL.indexOf(Portal.FRIENDLY_URL_SEPARATOR);
3472
3473 if (y != -1) {
3474 layoutFriendlyURL = layoutFriendlyURL.substring(0, y);
3475 }
3476 }
3477 else {
3478 layoutFriendlyURL = layout.getFriendlyURL(originalLocale);
3479 }
3480
3481 String friendlyURL = StringPool.SLASH;
3482
3483 if (requestURI.contains(layoutFriendlyURL)) {
3484 requestURI = StringUtil.replaceFirst(
3485 requestURI, layoutFriendlyURL, layout.getFriendlyURL(locale));
3486
3487 friendlyURL = layout.getFriendlyURL(locale);
3488 }
3489
3490 LayoutSet layoutSet = layout.getLayoutSet();
3491
3492 String virtualHostname = layoutSet.getVirtualHostname();
3493
3494 String portalURL = getPortalURL(request);
3495
3496 if (Validator.isNull(virtualHostname) ||
3497 !portalURL.contains(virtualHostname)) {
3498
3499 friendlyURL = requestURI;
3500 }
3501
3502 String i18nPath =
3503 StringPool.SLASH +
3504 getI18nPathLanguageId(locale, LocaleUtil.toLanguageId(locale));
3505
3506 boolean appendI18nPath = true;
3507
3508 if ((PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 0) ||
3509 ((PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 1) &&
3510 locale.equals(LocaleUtil.getDefault()))) {
3511
3512 appendI18nPath = false;
3513 }
3514
3515 String localizedFriendlyURL = contextPath;
3516
3517 if (appendI18nPath) {
3518 localizedFriendlyURL += i18nPath;
3519 }
3520
3521 localizedFriendlyURL += friendlyURL;
3522
3523 String queryString = request.getQueryString();
3524
3525 if (Validator.isNotNull(queryString)) {
3526 localizedFriendlyURL +=
3527 StringPool.QUESTION + request.getQueryString();
3528 }
3529
3530 return localizedFriendlyURL;
3531 }
3532
3533 @Override
3534 public String getMailId(String mx, String popPortletPrefix, Object... ids) {
3535 StringBundler sb = new StringBundler(ids.length * 2 + 7);
3536
3537 sb.append(StringPool.LESS_THAN);
3538 sb.append(popPortletPrefix);
3539
3540 if (!popPortletPrefix.endsWith(StringPool.PERIOD)) {
3541 sb.append(StringPool.PERIOD);
3542 }
3543
3544 for (int i = 0; i < ids.length; i++) {
3545 Object id = ids[i];
3546
3547 if (i != 0) {
3548 sb.append(StringPool.PERIOD);
3549 }
3550
3551 sb.append(id);
3552 }
3553
3554 sb.append(StringPool.AT);
3555
3556 if (Validator.isNotNull(PropsValues.POP_SERVER_SUBDOMAIN)) {
3557 sb.append(PropsValues.POP_SERVER_SUBDOMAIN);
3558 sb.append(StringPool.PERIOD);
3559 }
3560
3561 sb.append(mx);
3562 sb.append(StringPool.GREATER_THAN);
3563
3564 return sb.toString();
3565 }
3566
3567 @Override
3568 public String getNetvibesURL(Portlet portlet, ThemeDisplay themeDisplay)
3569 throws PortalException {
3570
3571 return getServletURL(
3572 portlet, PropsValues.NETVIBES_SERVLET_MAPPING, themeDisplay);
3573 }
3574
3575 @Override
3576 public String getNewPortletTitle(
3577 String portletTitle, String oldScopeName, String newScopeName) {
3578
3579 if (portletTitle.endsWith(" (" + oldScopeName + ")")) {
3580 int pos = portletTitle.lastIndexOf(" (" + oldScopeName + ")");
3581
3582 portletTitle = portletTitle.substring(0, pos);
3583 }
3584
3585 if (Validator.isNull(newScopeName)) {
3586 return portletTitle;
3587 }
3588
3589 return StringUtil.appendParentheticalSuffix(portletTitle, newScopeName);
3590 }
3591
3592 @Override
3593 public HttpServletRequest getOriginalServletRequest(
3594 HttpServletRequest request) {
3595
3596 List<PersistentHttpServletRequestWrapper>
3597 persistentHttpServletRequestWrappers = new ArrayList<>();
3598
3599 HttpServletRequest originalRequest = request;
3600
3601 while (originalRequest instanceof HttpServletRequestWrapper) {
3602 if (originalRequest instanceof
3603 PersistentHttpServletRequestWrapper) {
3604
3605 PersistentHttpServletRequestWrapper
3606 persistentHttpServletRequestWrapper =
3607 (PersistentHttpServletRequestWrapper)originalRequest;
3608
3609 persistentHttpServletRequestWrappers.add(
3610 persistentHttpServletRequestWrapper.clone());
3611 }
3612
3613
3614
3615
3616 HttpServletRequestWrapper httpServletRequestWrapper =
3617 (HttpServletRequestWrapper)originalRequest;
3618
3619 originalRequest =
3620 (HttpServletRequest)httpServletRequestWrapper.getRequest();
3621 }
3622
3623 for (int i = persistentHttpServletRequestWrappers.size() - 1; i >= 0;
3624 i--) {
3625
3626 HttpServletRequestWrapper httpServletRequestWrapper =
3627 persistentHttpServletRequestWrappers.get(i);
3628
3629 httpServletRequestWrapper.setRequest(originalRequest);
3630
3631 originalRequest = httpServletRequestWrapper;
3632 }
3633
3634 return originalRequest;
3635 }
3636
3637
3640 @Deprecated
3641 @Override
3642 public long getParentGroupId(long groupId) {
3643 return getSiteGroupId(groupId);
3644 }
3645
3646 @Override
3647 public String getPathContext() {
3648 return _pathContext;
3649 }
3650
3651 @Override
3652 public String getPathContext(HttpServletRequest request) {
3653 return getPathContext(request.getContextPath());
3654 }
3655
3656 @Override
3657 public String getPathContext(PortletRequest portletRequest) {
3658 return getPathContext(portletRequest.getContextPath());
3659 }
3660
3661 @Override
3662 public String getPathContext(String contextPath) {
3663 return _pathProxy.concat(getContextPath(contextPath));
3664 }
3665
3666 @Override
3667 public String getPathFriendlyURLPrivateGroup() {
3668 return _pathFriendlyURLPrivateGroup;
3669 }
3670
3671 @Override
3672 public String getPathFriendlyURLPrivateUser() {
3673 return _pathFriendlyURLPrivateUser;
3674 }
3675
3676 @Override
3677 public String getPathFriendlyURLPublic() {
3678 return _pathFriendlyURLPublic;
3679 }
3680
3681 @Override
3682 public String getPathImage() {
3683 return _pathImage;
3684 }
3685
3686 @Override
3687 public String getPathMain() {
3688 return _pathMain;
3689 }
3690
3691 @Override
3692 public String getPathModule() {
3693 return _pathModule;
3694 }
3695
3696 @Override
3697 public String getPathProxy() {
3698 return _pathProxy;
3699 }
3700
3701 @Override
3702 public long getPlidFromFriendlyURL(long companyId, String friendlyURL) {
3703 if (Validator.isNull(friendlyURL)) {
3704 return LayoutConstants.DEFAULT_PLID;
3705 }
3706
3707 String[] urlParts = friendlyURL.split("\\/", 4);
3708
3709 if ((friendlyURL.charAt(0) != CharPool.SLASH) &&
3710 (urlParts.length != 4)) {
3711
3712 return LayoutConstants.DEFAULT_PLID;
3713 }
3714
3715 boolean privateLayout = true;
3716
3717 String urlPrefix = StringPool.SLASH + urlParts[1];
3718
3719 if (_PUBLIC_GROUP_SERVLET_MAPPING.equals(urlPrefix)) {
3720 privateLayout = false;
3721 }
3722 else if (_PRIVATE_GROUP_SERVLET_MAPPING.equals(urlPrefix) ||
3723 _PRIVATE_USER_SERVLET_MAPPING.equals(urlPrefix)) {
3724
3725 privateLayout = true;
3726 }
3727 else {
3728 return LayoutConstants.DEFAULT_PLID;
3729 }
3730
3731 Group group = null;
3732
3733 try {
3734 group = GroupLocalServiceUtil.getFriendlyURLGroup(
3735 companyId, StringPool.SLASH + urlParts[2]);
3736 }
3737 catch (Exception e) {
3738 }
3739
3740 if (group == null) {
3741 return LayoutConstants.DEFAULT_PLID;
3742 }
3743
3744 Layout layout = null;
3745
3746 try {
3747 String layoutFriendlyURL = null;
3748
3749 if (urlParts.length == 4) {
3750 layoutFriendlyURL = StringPool.SLASH + urlParts[3];
3751
3752 layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
3753 group.getGroupId(), privateLayout, layoutFriendlyURL);
3754 }
3755 else {
3756 List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
3757 group.getGroupId(), privateLayout,
3758 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID, true, 0, 1);
3759
3760 if (!layouts.isEmpty()) {
3761 layout = layouts.get(0);
3762 }
3763 else {
3764 return LayoutConstants.DEFAULT_PLID;
3765 }
3766 }
3767
3768 return layout.getPlid();
3769 }
3770 catch (Exception e) {
3771 }
3772
3773 return LayoutConstants.DEFAULT_PLID;
3774 }
3775
3776 @Override
3777 public long getPlidFromPortletId(
3778 long groupId, boolean privateLayout, String portletId) {
3779
3780 long plid = LayoutConstants.DEFAULT_PLID;
3781
3782 StringBundler sb = new StringBundler(5);
3783
3784 sb.append(groupId);
3785 sb.append(StringPool.SPACE);
3786 sb.append(privateLayout);
3787 sb.append(StringPool.SPACE);
3788 sb.append(portletId);
3789
3790 String key = sb.toString();
3791
3792 Long plidObj = _plidToPortletIdMap.get(key);
3793
3794 if (plidObj == null) {
3795 plid = doGetPlidFromPortletId(groupId, privateLayout, portletId);
3796
3797 if (plid != LayoutConstants.DEFAULT_PLID) {
3798 _plidToPortletIdMap.put(key, plid);
3799 }
3800 }
3801 else {
3802 plid = plidObj.longValue();
3803
3804 boolean validPlid = false;
3805
3806 try {
3807 Layout layout = LayoutLocalServiceUtil.getLayout(plid);
3808
3809 LayoutTypePortlet layoutTypePortlet =
3810 (LayoutTypePortlet)layout.getLayoutType();
3811
3812 if (layoutTypePortlet.hasDefaultScopePortletId(
3813 groupId, portletId)) {
3814
3815 validPlid = true;
3816 }
3817 }
3818 catch (Exception e) {
3819 }
3820
3821 if (!validPlid) {
3822 _plidToPortletIdMap.remove(key);
3823
3824 plid = doGetPlidFromPortletId(
3825 groupId, privateLayout, portletId);
3826
3827 if (plid != LayoutConstants.DEFAULT_PLID) {
3828 _plidToPortletIdMap.put(key, plid);
3829 }
3830 }
3831 }
3832
3833 return plid;
3834 }
3835
3836 @Override
3837 public long getPlidFromPortletId(long groupId, String portletId) {
3838 long plid = getPlidFromPortletId(groupId, false, portletId);
3839
3840 if (plid == LayoutConstants.DEFAULT_PLID) {
3841 plid = getPlidFromPortletId(groupId, true, portletId);
3842 }
3843
3844 if (plid == LayoutConstants.DEFAULT_PLID) {
3845 if (_log.isDebugEnabled()) {
3846 _log.debug(
3847 "Portlet " + portletId +
3848 " does not exist on a page in group " + groupId);
3849 }
3850 }
3851
3852 return plid;
3853 }
3854
3855 @Override
3856 public PortalInetSocketAddressEventListener[]
3857 getPortalInetSocketAddressEventListeners() {
3858
3859 return _portalInetSocketAddressEventListeners.toArray(
3860 new PortalInetSocketAddressEventListener[
3861 _portalInetSocketAddressEventListeners.size()]);
3862 }
3863
3864 @Override
3865 public String getPortalLibDir() {
3866 return PropsValues.LIFERAY_LIB_PORTAL_DIR;
3867 }
3868
3869 @Override
3870 public InetAddress getPortalLocalInetAddress(boolean secure) {
3871 InetSocketAddress inetSocketAddress = null;
3872
3873 if (secure) {
3874 inetSocketAddress = _securePortalLocalInetSocketAddress.get();
3875 }
3876 else {
3877 inetSocketAddress = _portalLocalInetSocketAddress.get();
3878 }
3879
3880 if (inetSocketAddress == null) {
3881 return null;
3882 }
3883
3884 return inetSocketAddress.getAddress();
3885 }
3886
3887 @Override
3888 public int getPortalLocalPort(boolean secure) {
3889 InetSocketAddress inetSocketAddress = null;
3890
3891 if (secure) {
3892 inetSocketAddress = _securePortalLocalInetSocketAddress.get();
3893 }
3894 else {
3895 inetSocketAddress = _portalLocalInetSocketAddress.get();
3896 }
3897
3898 if (inetSocketAddress == null) {
3899 return -1;
3900 }
3901
3902 return inetSocketAddress.getPort();
3903 }
3904
3905
3908 @Deprecated
3909 @Override
3910 public int getPortalPort() {
3911 return getPortalServerPort(false);
3912 }
3913
3914
3918 @Deprecated
3919 @Override
3920 public int getPortalPort(boolean secure) {
3921 return getPortalServerPort(secure);
3922 }
3923
3924 @Override
3925 public Properties getPortalProperties() {
3926 return PropsUtil.getProperties();
3927 }
3928
3929 @Override
3930 public InetAddress getPortalServerInetAddress(boolean secure) {
3931 InetSocketAddress inetSocketAddress = null;
3932
3933 if (secure) {
3934 inetSocketAddress = _securePortalServerInetSocketAddress.get();
3935 }
3936 else {
3937 inetSocketAddress = _portalServerInetSocketAddress.get();
3938 }
3939
3940 if (inetSocketAddress == null) {
3941 return null;
3942 }
3943
3944 return inetSocketAddress.getAddress();
3945 }
3946
3947 @Override
3948 public int getPortalServerPort(boolean secure) {
3949 InetSocketAddress inetSocketAddress = null;
3950
3951 if (secure) {
3952 inetSocketAddress = _securePortalServerInetSocketAddress.get();
3953 }
3954 else {
3955 inetSocketAddress = _portalServerInetSocketAddress.get();
3956 }
3957
3958 if (inetSocketAddress == null) {
3959 return -1;
3960 }
3961
3962 return inetSocketAddress.getPort();
3963 }
3964
3965 @Override
3966 public String getPortalURL(HttpServletRequest request) {
3967 return getPortalURL(request, isSecure(request));
3968 }
3969
3970 @Override
3971 public String getPortalURL(HttpServletRequest request, boolean secure) {
3972 return getPortalURL(
3973 request.getServerName(), request.getServerPort(), secure);
3974 }
3975
3976 @Override
3977 public String getPortalURL(Layout layout, ThemeDisplay themeDisplay)
3978 throws PortalException {
3979
3980 String serverName = themeDisplay.getServerName();
3981
3982 if (layout == null) {
3983 layout = themeDisplay.getLayout();
3984 }
3985
3986 if (layout != null) {
3987 Layout virtualHostLayout = layout;
3988
3989 long refererPlid = themeDisplay.getRefererPlid();
3990
3991 if (refererPlid > 0) {
3992 virtualHostLayout = LayoutLocalServiceUtil.getLayout(
3993 refererPlid);
3994 }
3995
3996 LayoutSet virtualHostLayoutSet = virtualHostLayout.getLayoutSet();
3997
3998 String virtualHostname = virtualHostLayoutSet.getVirtualHostname();
3999
4000 String domain = HttpUtil.getDomain(themeDisplay.getURLPortal());
4001
4002 if (Validator.isNotNull(virtualHostname) &&
4003 domain.startsWith(virtualHostname)) {
4004
4005 serverName = virtualHostname;
4006 }
4007 }
4008
4009 return getPortalURL(
4010 serverName, themeDisplay.getServerPort(), themeDisplay.isSecure());
4011 }
4012
4013 @Override
4014 public String getPortalURL(PortletRequest portletRequest) {
4015 return getPortalURL(portletRequest, portletRequest.isSecure());
4016 }
4017
4018 @Override
4019 public String getPortalURL(PortletRequest portletRequest, boolean secure) {
4020 return getPortalURL(
4021 portletRequest.getServerName(), portletRequest.getServerPort(),
4022 secure);
4023 }
4024
4025 @Override
4026 public String getPortalURL(
4027 String serverName, int serverPort, boolean secure) {
4028
4029 StringBundler sb = new StringBundler(4);
4030
4031 boolean https =
4032 (secure ||
4033 StringUtil.equalsIgnoreCase(
4034 Http.HTTPS, PropsValues.WEB_SERVER_PROTOCOL));
4035
4036 if (https) {
4037 sb.append(Http.HTTPS_WITH_SLASH);
4038 }
4039 else {
4040 sb.append(Http.HTTP_WITH_SLASH);
4041 }
4042
4043 if (Validator.isNull(PropsValues.WEB_SERVER_HOST)) {
4044 sb.append(serverName);
4045 }
4046 else {
4047 sb.append(PropsValues.WEB_SERVER_HOST);
4048 }
4049
4050 if (!https) {
4051 if (PropsValues.WEB_SERVER_HTTP_PORT == -1) {
4052 if ((serverPort != Http.HTTP_PORT) &&
4053 (serverPort != Http.HTTPS_PORT)) {
4054
4055 sb.append(StringPool.COLON);
4056 sb.append(serverPort);
4057 }
4058 }
4059 else {
4060 if (PropsValues.WEB_SERVER_HTTP_PORT != Http.HTTP_PORT) {
4061 sb.append(StringPool.COLON);
4062 sb.append(PropsValues.WEB_SERVER_HTTP_PORT);
4063 }
4064 }
4065 }
4066 else {
4067 if (PropsValues.WEB_SERVER_HTTPS_PORT == -1) {
4068 if ((serverPort != Http.HTTP_PORT) &&
4069 (serverPort != Http.HTTPS_PORT)) {
4070
4071 sb.append(StringPool.COLON);
4072 sb.append(serverPort);
4073 }
4074 }
4075 else {
4076 if (PropsValues.WEB_SERVER_HTTPS_PORT != Http.HTTPS_PORT) {
4077 sb.append(StringPool.COLON);
4078 sb.append(PropsValues.WEB_SERVER_HTTPS_PORT);
4079 }
4080 }
4081 }
4082
4083 return sb.toString();
4084 }
4085
4086 @Override
4087 public String getPortalURL(ThemeDisplay themeDisplay)
4088 throws PortalException {
4089
4090 return getPortalURL(null, themeDisplay);
4091 }
4092
4093 @Override
4094 public String getPortalWebDir() {
4095 return PropsValues.LIFERAY_WEB_PORTAL_DIR;
4096 }
4097
4098
4102 @Deprecated
4103 @Override
4104 public Set<String> getPortletAddDefaultResourceCheckWhitelist() {
4105 return AuthTokenWhitelistUtil.getPortletInvocationWhitelist();
4106 }
4107
4108
4112 @Deprecated
4113 @Override
4114 public Set<String> getPortletAddDefaultResourceCheckWhitelistActions() {
4115 return AuthTokenWhitelistUtil.getPortletInvocationWhitelistActions();
4116 }
4117
4118
4122 @Deprecated
4123 @Override
4124 public List<BreadcrumbEntry> getPortletBreadcrumbList(
4125 HttpServletRequest request) {
4126
4127 return getPortletBreadcrumbs(request);
4128 }
4129
4130
4135 @Deprecated
4136 @Override
4137 public List<BreadcrumbEntry> getPortletBreadcrumbs(
4138 HttpServletRequest request) {
4139
4140 return BreadcrumbUtil.getPortletBreadcrumbEntries(request);
4141 }
4142
4143 @Override
4144 public PortletConfig getPortletConfig(
4145 long companyId, String portletId, ServletContext servletContext)
4146 throws PortletException {
4147
4148 Portlet portlet = PortletLocalServiceUtil.getPortletById(
4149 companyId, portletId);
4150
4151 InvokerPortlet invokerPortlet = PortletInstanceFactoryUtil.create(
4152 portlet, servletContext);
4153
4154 return invokerPortlet.getPortletConfig();
4155 }
4156
4157 @Override
4158 public String getPortletDescription(
4159 Portlet portlet, ServletContext servletContext, Locale locale) {
4160
4161 PortletConfig portletConfig = PortletConfigFactoryUtil.create(
4162 portlet, servletContext);
4163
4164 ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
4165
4166 String portletDescription = ResourceBundleUtil.getString(
4167 resourceBundle,
4168 JavaConstants.JAVAX_PORTLET_DESCRIPTION.concat(
4169 StringPool.PERIOD).concat(portlet.getRootPortletId()));
4170
4171 if (Validator.isNull(portletDescription)) {
4172 portletDescription = ResourceBundleUtil.getString(
4173 resourceBundle, JavaConstants.JAVAX_PORTLET_DESCRIPTION);
4174 }
4175
4176 return portletDescription;
4177 }
4178
4179 @Override
4180 public String getPortletDescription(Portlet portlet, User user) {
4181 return getPortletDescription(portlet.getPortletId(), user);
4182 }
4183
4184 @Override
4185 public String getPortletDescription(String portletId, Locale locale) {
4186 return LanguageUtil.get(
4187 locale,
4188 JavaConstants.JAVAX_PORTLET_DESCRIPTION.concat(
4189 StringPool.PERIOD).concat(portletId));
4190 }
4191
4192 @Override
4193 public String getPortletDescription(String portletId, String languageId) {
4194 Locale locale = LocaleUtil.fromLanguageId(languageId);
4195
4196 return getPortletDescription(portletId, locale);
4197 }
4198
4199 @Override
4200 public String getPortletDescription(String portletId, User user) {
4201 return LanguageUtil.get(
4202 user.getLocale(),
4203 JavaConstants.JAVAX_PORTLET_DESCRIPTION.concat(
4204 StringPool.PERIOD).concat(portletId));
4205 }
4206
4207 public LayoutQueryStringComposite
4208 getPortletFriendlyURLMapperLayoutQueryStringComposite(
4209 long groupId, boolean privateLayout, String url,
4210 Map<String, String[]> params,
4211 Map<String, Object> requestContext)
4212 throws PortalException {
4213
4214 boolean foundFriendlyURLMapper = false;
4215
4216 String friendlyURL = url;
4217 String queryString = StringPool.BLANK;
4218
4219 List<Portlet> portlets =
4220 PortletLocalServiceUtil.getFriendlyURLMapperPortlets();
4221
4222 for (Portlet portlet : portlets) {
4223 FriendlyURLMapper friendlyURLMapper =
4224 portlet.getFriendlyURLMapperInstance();
4225
4226 if (url.endsWith(
4227 StringPool.SLASH + friendlyURLMapper.getMapping())) {
4228
4229 url += StringPool.SLASH;
4230 }
4231
4232 int pos = -1;
4233
4234 if (friendlyURLMapper.isCheckMappingWithPrefix()) {
4235 pos = url.indexOf(
4236 FRIENDLY_URL_SEPARATOR + friendlyURLMapper.getMapping() +
4237 StringPool.SLASH);
4238 }
4239 else {
4240 pos = url.indexOf(
4241 StringPool.SLASH + friendlyURLMapper.getMapping() +
4242 StringPool.SLASH);
4243 }
4244
4245 if (pos != -1) {
4246 foundFriendlyURLMapper = true;
4247
4248 friendlyURL = url.substring(0, pos);
4249
4250 InheritableMap<String, String[]> actualParams =
4251 new InheritableMap<>();
4252
4253 if (params != null) {
4254 actualParams.setParentMap(params);
4255 }
4256
4257 Map<String, String> prpIdentifiers = new HashMap<>();
4258
4259 Set<PublicRenderParameter> publicRenderParameters =
4260 portlet.getPublicRenderParameters();
4261
4262 for (PublicRenderParameter publicRenderParameter :
4263 publicRenderParameters) {
4264
4265 QName qName = publicRenderParameter.getQName();
4266
4267 String publicRenderParameterIdentifier =
4268 qName.getLocalPart();
4269 String publicRenderParameterName =
4270 PortletQNameUtil.getPublicRenderParameterName(qName);
4271
4272 prpIdentifiers.put(
4273 publicRenderParameterIdentifier,
4274 publicRenderParameterName);
4275 }
4276
4277 FriendlyURLMapperThreadLocal.setPRPIdentifiers(prpIdentifiers);
4278
4279 if (friendlyURLMapper.isCheckMappingWithPrefix()) {
4280 friendlyURLMapper.populateParams(
4281 url.substring(pos + 2), actualParams, requestContext);
4282 }
4283 else {
4284 friendlyURLMapper.populateParams(
4285 url.substring(pos), actualParams, requestContext);
4286 }
4287
4288 queryString =
4289 StringPool.AMPERSAND +
4290 HttpUtil.parameterMapToString(actualParams, false);
4291
4292 break;
4293 }
4294 }
4295
4296 if (!foundFriendlyURLMapper) {
4297 int x = url.indexOf(FRIENDLY_URL_SEPARATOR);
4298
4299 if (x != -1) {
4300 int y = url.indexOf(CharPool.SLASH, x + 3);
4301
4302 if (y == -1) {
4303 y = url.length();
4304 }
4305
4306 String ppid = url.substring(x + 3, y);
4307
4308 if (Validator.isNotNull(ppid)) {
4309 friendlyURL = url.substring(0, x);
4310
4311 Map<String, String[]> actualParams = null;
4312
4313 if (params != null) {
4314 actualParams = new HashMap<>(params);
4315 }
4316 else {
4317 actualParams = new HashMap<>();
4318 }
4319
4320 actualParams.put("p_p_id", new String[] {ppid});
4321 actualParams.put("p_p_lifecycle", new String[] {"0"});
4322 actualParams.put(
4323 "p_p_state",
4324 new String[] {WindowState.MAXIMIZED.toString()});
4325 actualParams.put(
4326 "p_p_mode", new String[] {PortletMode.VIEW.toString()});
4327
4328 queryString =
4329 StringPool.AMPERSAND +
4330 HttpUtil.parameterMapToString(actualParams, false);
4331 }
4332 }
4333 }
4334
4335 friendlyURL = StringUtil.replace(
4336 friendlyURL, StringPool.DOUBLE_SLASH, StringPool.SLASH);
4337
4338 if (friendlyURL.endsWith(StringPool.SLASH)) {
4339 friendlyURL = friendlyURL.substring(0, friendlyURL.length() - 1);
4340 }
4341
4342 Layout layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
4343 groupId, privateLayout, friendlyURL);
4344
4345 return new LayoutQueryStringComposite(layout, friendlyURL, queryString);
4346 }
4347
4348 @Override
4349 public String getPortletId(HttpServletRequest request) {
4350 LiferayPortletConfig liferayPortletConfig =
4351 (LiferayPortletConfig)request.getAttribute(
4352 JavaConstants.JAVAX_PORTLET_CONFIG);
4353
4354 if (liferayPortletConfig != null) {
4355 return liferayPortletConfig.getPortletId();
4356 }
4357 else {
4358 return null;
4359 }
4360 }
4361
4362 @Override
4363 public String getPortletId(PortletRequest portletRequest) {
4364 LiferayPortletConfig liferayPortletConfig =
4365 (LiferayPortletConfig)portletRequest.getAttribute(
4366 JavaConstants.JAVAX_PORTLET_CONFIG);
4367
4368 if (liferayPortletConfig != null) {
4369 return liferayPortletConfig.getPortletId();
4370 }
4371 else {
4372 return null;
4373 }
4374 }
4375
4376 @Override
4377 public String getPortletLongTitle(Portlet portlet, Locale locale) {
4378 return getPortletLongTitle(portlet.getPortletId(), locale);
4379 }
4380
4381 @Override
4382 public String getPortletLongTitle(
4383 Portlet portlet, ServletContext servletContext, Locale locale) {
4384
4385 PortletConfig portletConfig = PortletConfigFactoryUtil.create(
4386 portlet, servletContext);
4387
4388 ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
4389
4390 try {
4391 String portletLongTitle = ResourceBundleUtil.getString(
4392 resourceBundle, JavaConstants.JAVAX_PORTLET_LONG_TITLE);
4393
4394 if (portletLongTitle.startsWith(
4395 JavaConstants.JAVAX_PORTLET_LONG_TITLE)) {
4396
4397 portletLongTitle = getPortletTitle(
4398 portlet, servletContext, locale);
4399 }
4400
4401 return portletLongTitle;
4402 }
4403 catch (Exception e) {
4404 return getPortletTitle(portlet, servletContext, locale);
4405 }
4406 }
4407
4408 @Override
4409 public String getPortletLongTitle(Portlet portlet, String languageId) {
4410 return getPortletLongTitle(portlet.getPortletId(), languageId);
4411 }
4412
4413 @Override
4414 public String getPortletLongTitle(Portlet portlet, User user) {
4415 return getPortletLongTitle(portlet.getPortletId(), user);
4416 }
4417
4418 @Override
4419 public String getPortletLongTitle(String portletId, Locale locale) {
4420 String portletLongTitle = LanguageUtil.get(
4421 locale,
4422 JavaConstants.JAVAX_PORTLET_LONG_TITLE.concat(
4423 StringPool.PERIOD).concat(portletId),
4424 StringPool.BLANK);
4425
4426 if (Validator.isNull(portletLongTitle)) {
4427 portletLongTitle = getPortletTitle(portletId, locale);
4428 }
4429
4430 return portletLongTitle;
4431 }
4432
4433 @Override
4434 public String getPortletLongTitle(String portletId, String languageId) {
4435 Locale locale = LocaleUtil.fromLanguageId(languageId);
4436
4437 return getPortletLongTitle(portletId, locale);
4438 }
4439
4440 @Override
4441 public String getPortletLongTitle(String portletId, User user) {
4442 return getPortletLongTitle(portletId, user.getLocale());
4443 }
4444
4445 @Override
4446 public String getPortletNamespace(String portletId) {
4447 return StringPool.UNDERLINE.concat(portletId).concat(
4448 StringPool.UNDERLINE);
4449 }
4450
4451 @Override
4452 public String getPortletTitle(Portlet portlet, Locale locale) {
4453 return getPortletTitle(portlet.getPortletId(), locale);
4454 }
4455
4456 @Override
4457 public String getPortletTitle(
4458 Portlet portlet, ServletContext servletContext, Locale locale) {
4459
4460 PortletConfig portletConfig = PortletConfigFactoryUtil.create(
4461 portlet, servletContext);
4462
4463 ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
4464
4465 String portletTitle = ResourceBundleUtil.getString(
4466 resourceBundle,
4467 JavaConstants.JAVAX_PORTLET_TITLE.concat(StringPool.PERIOD).concat(
4468 portlet.getRootPortletId()));
4469
4470 if (Validator.isNull(portletTitle)) {
4471 portletTitle = ResourceBundleUtil.getString(
4472 resourceBundle, JavaConstants.JAVAX_PORTLET_TITLE);
4473 }
4474
4475 return portletTitle;
4476 }
4477
4478 @Override
4479 public String getPortletTitle(Portlet portlet, String languageId) {
4480 return getPortletTitle(portlet.getPortletId(), languageId);
4481 }
4482
4483 @Override
4484 public String getPortletTitle(Portlet portlet, User user) {
4485 return getPortletTitle(portlet.getPortletId(), user);
4486 }
4487
4488 @Override
4489 public String getPortletTitle(PortletRequest portletRequest) {
4490 long companyId = getCompanyId(portletRequest);
4491 String portletId = (String)portletRequest.getAttribute(
4492 WebKeys.PORTLET_ID);
4493
4494 Portlet portlet = PortletLocalServiceUtil.getPortletById(
4495 companyId, portletId);
4496
4497 HttpServletRequest request = getHttpServletRequest(portletRequest);
4498
4499 ServletContext servletContext = (ServletContext)request.getAttribute(
4500 WebKeys.CTX);
4501
4502 Locale locale = portletRequest.getLocale();
4503
4504 return getPortletTitle(portlet, servletContext, locale);
4505 }
4506
4507 @Override
4508 public String getPortletTitle(PortletResponse portletResponse) {
4509 PortletResponseImpl portletResponseImpl =
4510 PortletResponseImpl.getPortletResponseImpl(portletResponse);
4511
4512 return ((RenderResponseImpl)portletResponseImpl).getTitle();
4513 }
4514
4515 @Override
4516 public String getPortletTitle(String portletId, Locale locale) {
4517 PortletConfig portletConfig = PortletConfigFactoryUtil.get(portletId);
4518
4519 return getPortletTitle(
4520 portletId, portletConfig.getResourceBundle(locale));
4521 }
4522
4523 @Override
4524 public String getPortletTitle(
4525 String portletId, ResourceBundle resourceBundle) {
4526
4527 portletId = PortletConstants.getRootPortletId(portletId);
4528
4529 String portletTitle = LanguageUtil.get(
4530 resourceBundle,
4531 JavaConstants.JAVAX_PORTLET_TITLE.concat(StringPool.PERIOD).concat(
4532 portletId),
4533 null);
4534
4535 if (Validator.isNull(portletTitle)) {
4536 portletTitle = ResourceBundleUtil.getString(
4537 resourceBundle, JavaConstants.JAVAX_PORTLET_TITLE);
4538 }
4539
4540 return portletTitle;
4541 }
4542
4543 @Override
4544 public String getPortletTitle(String portletId, String languageId) {
4545 Locale locale = LocaleUtil.fromLanguageId(languageId);
4546
4547 return getPortletTitle(portletId, locale);
4548 }
4549
4550 @Override
4551 public String getPortletTitle(String portletId, User user) {
4552 return LanguageUtil.get(
4553 user.getLocale(),
4554 JavaConstants.JAVAX_PORTLET_TITLE.concat(StringPool.PERIOD).concat(
4555 portletId));
4556 }
4557
4558 @Override
4559 public String getPortletXmlFileName() {
4560 if (PrefsPropsUtil.getBoolean(
4561 PropsKeys.AUTO_DEPLOY_CUSTOM_PORTLET_XML,
4562 PropsValues.AUTO_DEPLOY_CUSTOM_PORTLET_XML)) {
4563
4564 return PORTLET_XML_FILE_NAME_CUSTOM;
4565 }
4566 else {
4567 return PORTLET_XML_FILE_NAME_STANDARD;
4568 }
4569 }
4570
4571 @Override
4572 public PortletPreferences getPreferences(HttpServletRequest request) {
4573 RenderRequest renderRequest = (RenderRequest)request.getAttribute(
4574 JavaConstants.JAVAX_PORTLET_REQUEST);
4575
4576 PortletPreferences portletPreferences = null;
4577
4578 if (renderRequest != null) {
4579 PortletPreferencesWrapper portletPreferencesWrapper =
4580 (PortletPreferencesWrapper)renderRequest.getPreferences();
4581
4582 portletPreferences =
4583 portletPreferencesWrapper.getPortletPreferencesImpl();
4584 }
4585
4586 return portletPreferences;
4587 }
4588
4589 @Override
4590 public PreferencesValidator getPreferencesValidator(Portlet portlet) {
4591 PortletBag portletBag = PortletBagPool.get(portlet.getRootPortletId());
4592
4593 if (portletBag == null) {
4594 return null;
4595 }
4596
4597 List<PreferencesValidator> preferencesValidatorInstances =
4598 portletBag.getPreferencesValidatorInstances();
4599
4600 if (preferencesValidatorInstances.isEmpty()) {
4601 return null;
4602 }
4603
4604 return preferencesValidatorInstances.get(0);
4605 }
4606
4607 @Override
4608 public String getRelativeHomeURL(HttpServletRequest request)
4609 throws PortalException {
4610
4611 Company company = getCompany(request);
4612
4613 String homeURL = company.getHomeURL();
4614
4615 if (Validator.isNull(homeURL)) {
4616 homeURL = PropsValues.COMPANY_DEFAULT_HOME_URL;
4617 }
4618
4619 return homeURL;
4620 }
4621
4622 @Override
4623 public ResourceBundle getResourceBundle(Locale locale) {
4624 return LanguageResources.getResourceBundle(locale);
4625 }
4626
4627 @Override
4628 public long getScopeGroupId(HttpServletRequest request)
4629 throws PortalException {
4630
4631 String portletId = getPortletId(request);
4632
4633 return getScopeGroupId(request, portletId);
4634 }
4635
4636 @Override
4637 public long getScopeGroupId(HttpServletRequest request, String portletId)
4638 throws PortalException {
4639
4640 return getScopeGroupId(request, portletId, false);
4641 }
4642
4643 @Override
4644 public long getScopeGroupId(
4645 HttpServletRequest request, String portletId,
4646 boolean checkStagingGroup)
4647 throws PortalException {
4648
4649 Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
4650
4651 long scopeGroupId = 0;
4652
4653 if (layout != null) {
4654 Group group = layout.getGroup();
4655
4656 long doAsGroupId = ParamUtil.getLong(request, "doAsGroupId");
4657
4658 if (doAsGroupId <= 0) {
4659 HttpServletRequest originalRequest = getOriginalServletRequest(
4660 request);
4661
4662 doAsGroupId = ParamUtil.getLong(originalRequest, "doAsGroupId");
4663 }
4664
4665 Group doAsGroup = null;
4666
4667 if (doAsGroupId > 0) {
4668 doAsGroup = GroupLocalServiceUtil.fetchGroup(doAsGroupId);
4669 }
4670
4671 if (group.isControlPanel()) {
4672 if (doAsGroupId > 0) {
4673 scopeGroupId = doAsGroupId;
4674 }
4675
4676 group = GroupLocalServiceUtil.fetchGroup(scopeGroupId);
4677
4678 if ((group != null) && group.hasStagingGroup()) {
4679 try {
4680 Group stagingGroup = group.getStagingGroup();
4681
4682 scopeGroupId = stagingGroup.getGroupId();
4683 }
4684 catch (Exception e) {
4685 }
4686 }
4687 }
4688 else if (doAsGroup != null) {
4689 scopeGroupId = doAsGroupId;
4690 }
4691
4692 if ((group != null) && group.isInheritContent()) {
4693 Group layoutGroup = layout.getGroup();
4694
4695 if (!layoutGroup.isControlPanel()) {
4696 scopeGroupId = group.getParentGroupId();
4697 }
4698 }
4699
4700 if ((portletId != null) && (group != null) &&
4701 (group.isStaged() || group.isStagingGroup())) {
4702
4703 Group liveGroup = group;
4704
4705 if (group.isStagingGroup()) {
4706 liveGroup = group.getLiveGroup();
4707 }
4708
4709 if (liveGroup.isStaged() &&
4710 !liveGroup.isStagedPortlet(portletId)) {
4711
4712 Layout liveGroupLayout =
4713 LayoutLocalServiceUtil.fetchLayoutByUuidAndGroupId(
4714 layout.getUuid(), liveGroup.getGroupId(),
4715 layout.isPrivateLayout());
4716
4717 if ((liveGroupLayout != null) &&
4718 liveGroupLayout.hasScopeGroup()) {
4719
4720 scopeGroupId = getScopeGroupId(
4721 liveGroupLayout, portletId);
4722 }
4723 else if (checkStagingGroup &&
4724 !liveGroup.isStagedRemotely()) {
4725
4726 Group stagingGroup = liveGroup.getStagingGroup();
4727
4728 scopeGroupId = stagingGroup.getGroupId();
4729 }
4730 else {
4731 scopeGroupId = liveGroup.getGroupId();
4732 }
4733 }
4734 }
4735 }
4736
4737 if (scopeGroupId <= 0) {
4738 scopeGroupId = getScopeGroupId(layout, portletId);
4739 }
4740
4741 return scopeGroupId;
4742 }
4743
4744 @Override
4745 public long getScopeGroupId(Layout layout) {
4746 if (layout == null) {
4747 return 0;
4748 }
4749 else {
4750 return layout.getGroupId();
4751 }
4752 }
4753
4754 @Override
4755 public long getScopeGroupId(Layout layout, String portletId) {
4756 if (layout == null) {
4757 return 0;
4758 }
4759
4760 if (Validator.isNull(portletId)) {
4761 return layout.getGroupId();
4762 }
4763
4764 try {
4765 PortletPreferences portletSetup =
4766 PortletPreferencesFactoryUtil.getStrictLayoutPortletSetup(
4767 layout, portletId);
4768
4769 String scopeType = GetterUtil.getString(
4770 portletSetup.getValue("lfrScopeType", null));
4771
4772 if (Validator.isNull(scopeType)) {
4773 return layout.getGroupId();
4774 }
4775
4776 if (scopeType.equals("company")) {
4777 Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
4778 layout.getCompanyId());
4779
4780 return companyGroup.getGroupId();
4781 }
4782
4783 String scopeLayoutUuid = GetterUtil.getString(
4784 portletSetup.getValue("lfrScopeLayoutUuid", null));
4785
4786 Layout scopeLayout =
4787 LayoutLocalServiceUtil.getLayoutByUuidAndGroupId(
4788 scopeLayoutUuid, layout.getGroupId(),
4789 layout.isPrivateLayout());
4790
4791 Group scopeGroup = scopeLayout.getScopeGroup();
4792
4793 return scopeGroup.getGroupId();
4794 }
4795 catch (Exception e) {
4796 return layout.getGroupId();
4797 }
4798 }
4799
4800 @Override
4801 public long getScopeGroupId(long plid) {
4802 Layout layout = null;
4803
4804 try {
4805 layout = LayoutLocalServiceUtil.getLayout(plid);
4806 }
4807 catch (Exception e) {
4808 }
4809
4810 return getScopeGroupId(layout);
4811 }
4812
4813 @Override
4814 public long getScopeGroupId(PortletRequest portletRequest)
4815 throws PortalException {
4816
4817 return getScopeGroupId(getHttpServletRequest(portletRequest));
4818 }
4819
4820 @Override
4821 public User getSelectedUser(HttpServletRequest request)
4822 throws PortalException {
4823
4824 return getSelectedUser(request, true);
4825 }
4826
4827 @Override
4828 public User getSelectedUser(
4829 HttpServletRequest request, boolean checkPermission)
4830 throws PortalException {
4831
4832 long userId = ParamUtil.getLong(request, "p_u_i_d");
4833
4834 User user = null;
4835
4836 try {
4837 if (checkPermission) {
4838 user = UserServiceUtil.getUserById(userId);
4839 }
4840 else {
4841 user = UserLocalServiceUtil.getUserById(userId);
4842 }
4843 }
4844 catch (NoSuchUserException nsue) {
4845 }
4846
4847 return user;
4848 }
4849
4850 @Override
4851 public User getSelectedUser(PortletRequest portletRequest)
4852 throws PortalException {
4853
4854 return getSelectedUser(portletRequest, true);
4855 }
4856
4857 @Override
4858 public User getSelectedUser(
4859 PortletRequest portletRequest, boolean checkPermission)
4860 throws PortalException {
4861
4862 return getSelectedUser(
4863 getHttpServletRequest(portletRequest), checkPermission);
4864 }
4865
4866 @Override
4867 public String getServletContextName() {
4868 return _servletContextName;
4869 }
4870
4871 @Override
4872 public long[] getSharedContentSiteGroupIds(
4873 long companyId, long groupId, long userId)
4874 throws PortalException {
4875
4876 Set<Group> groups = new LinkedHashSet<>();
4877
4878 Group siteGroup = doGetCurrentSiteGroup(groupId);
4879
4880 if (siteGroup != null) {
4881
4882
4883
4884 groups.add(siteGroup);
4885
4886
4887
4888 groups.addAll(siteGroup.getDescendants(true));
4889
4890
4891
4892 groups.addAll(
4893 GroupLocalServiceUtil.getGroups(
4894 siteGroup.getCompanyId(), Layout.class.getName(),
4895 siteGroup.getGroupId()));
4896 }
4897
4898
4899
4900 if (PrefsPropsUtil.getBoolean(
4901 companyId,
4902 PropsKeys.
4903 SITES_CONTENT_SHARING_THROUGH_ADMINISTRATORS_ENABLED)) {
4904
4905 LinkedHashMap<String, Object> groupParams = new LinkedHashMap<>();
4906
4907 groupParams.put("site", Boolean.TRUE);
4908 groupParams.put("usersGroups", userId);
4909
4910 groups.addAll(
4911 GroupLocalServiceUtil.search(
4912 companyId, null, null, groupParams, QueryUtil.ALL_POS,
4913 QueryUtil.ALL_POS, null));
4914 }
4915
4916
4917
4918 int sitesContentSharingWithChildrenEnabled = PrefsPropsUtil.getInteger(
4919 companyId, PropsKeys.SITES_CONTENT_SHARING_WITH_CHILDREN_ENABLED);
4920
4921 if (sitesContentSharingWithChildrenEnabled !=
4922 Sites.CONTENT_SHARING_WITH_CHILDREN_DISABLED) {
4923
4924 groups.addAll(doGetAncestorSiteGroups(groupId, true));
4925 }
4926
4927 long[] groupIds = new long[groups.size()];
4928
4929 int i = 0;
4930
4931 for (Group group : groups) {
4932 groupIds[i++] = group.getGroupId();
4933 }
4934
4935 return groupIds;
4936 }
4937
4938
4943 @Deprecated
4944 @Override
4945 public PortletURL getSiteAdministrationURL(
4946 HttpServletRequest request, ThemeDisplay themeDisplay,
4947 String portletId) {
4948
4949 PortletURL portletURL = getControlPanelPortletURL(
4950 request, portletId, PortletRequest.RENDER_PHASE);
4951
4952 portletURL.setParameter("redirect", themeDisplay.getURLCurrent());
4953
4954 return portletURL;
4955 }
4956
4957
4962 @Deprecated
4963 @Override
4964 public PortletURL getSiteAdministrationURL(
4965 PortletResponse portletResponse, ThemeDisplay themeDisplay,
4966 String portletName) {
4967
4968 LiferayPortletResponse liferayPortletResponse =
4969 (LiferayPortletResponse)portletResponse;
4970
4971 LiferayPortletURL siteAdministrationURL =
4972 liferayPortletResponse.createRenderURL(portletName);
4973
4974 siteAdministrationURL.setDoAsGroupId(themeDisplay.getScopeGroupId());
4975 siteAdministrationURL.setParameter(
4976 "redirect", themeDisplay.getURLCurrent());
4977
4978 return siteAdministrationURL;
4979 }
4980
4981
4985 @Deprecated
4986 @Override
4987 public long[] getSiteAndCompanyGroupIds(long groupId)
4988 throws PortalException {
4989
4990 Group scopeGroup = GroupLocalServiceUtil.getGroup(groupId);
4991
4992 Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
4993 scopeGroup.getCompanyId());
4994
4995 if (scopeGroup.isLayout()) {
4996 return new long[] {
4997 groupId, scopeGroup.getParentGroupId(),
4998 companyGroup.getGroupId()
4999 };
5000 }
5001 else if (scopeGroup.isLayoutSetPrototype() ||
5002 scopeGroup.isOrganization() || scopeGroup.isRegularSite() ||
5003 scopeGroup.isUser()) {
5004
5005 return new long[] {groupId, companyGroup.getGroupId()};
5006 }
5007 else {
5008 return new long[] {companyGroup.getGroupId()};
5009 }
5010 }
5011
5012
5016 @Deprecated
5017 @Override
5018 public long[] getSiteAndCompanyGroupIds(ThemeDisplay themeDisplay)
5019 throws PortalException {
5020
5021 return getSiteAndCompanyGroupIds(themeDisplay.getScopeGroupId());
5022 }
5023
5024 @Override
5025 public Locale getSiteDefaultLocale(long groupId) throws PortalException {
5026 if (groupId <= 0) {
5027 return LocaleUtil.getDefault();
5028 }
5029
5030 Group group = GroupLocalServiceUtil.getGroup(groupId);
5031
5032 Group liveGroup = group;
5033
5034 if (group.isStagingGroup()) {
5035 liveGroup = group.getLiveGroup();
5036 }
5037
5038 if (LanguageUtil.isInheritLocales(liveGroup.getGroupId())) {
5039 return LocaleUtil.getDefault();
5040 }
5041
5042 UnicodeProperties typeSettingsProperties =
5043 liveGroup.getTypeSettingsProperties();
5044
5045 User defaultUser = UserLocalServiceUtil.getDefaultUser(
5046 group.getCompanyId());
5047
5048 String languageId = GetterUtil.getString(
5049 typeSettingsProperties.getProperty("languageId"),
5050 defaultUser.getLanguageId());
5051
5052 return LocaleUtil.fromLanguageId(languageId);
5053 }
5054
5055 @Override
5056 public long getSiteGroupId(long groupId) {
5057 if (groupId <= 0) {
5058 return 0;
5059 }
5060
5061 Group group = GroupLocalServiceUtil.fetchGroup(groupId);
5062
5063 if (group == null) {
5064 return 0;
5065 }
5066
5067 long siteGroupId = groupId;
5068
5069 if (group.isLayout()) {
5070 siteGroupId = group.getParentGroupId();
5071 }
5072
5073 return siteGroupId;
5074 }
5075
5076 @Override
5077 public String getSiteLoginURL(ThemeDisplay themeDisplay)
5078 throws PortalException {
5079
5080 if (Validator.isNull(PropsValues.AUTH_LOGIN_SITE_URL)) {
5081 return null;
5082 }
5083
5084 List<Layout> layouts = themeDisplay.getUnfilteredLayouts();
5085
5086 if (layouts == null) {
5087 return null;
5088 }
5089
5090 for (Layout layout : layouts) {
5091 String friendlyURL = layout.getFriendlyURL(
5092 themeDisplay.getLocale());
5093
5094 if (friendlyURL.equals(PropsValues.AUTH_LOGIN_SITE_URL)) {
5095 if (themeDisplay.getLayout() == null) {
5096 break;
5097 }
5098
5099 String layoutSetFriendlyURL = getLayoutSetFriendlyURL(
5100 layout.getLayoutSet(), themeDisplay);
5101
5102 return layoutSetFriendlyURL + PropsValues.AUTH_LOGIN_SITE_URL;
5103 }
5104 }
5105
5106 return null;
5107 }
5108
5109 @Override
5110 public String getStaticResourceURL(HttpServletRequest request, String uri) {
5111 return getStaticResourceURL(request, uri, null, 0);
5112 }
5113
5114 @Override
5115 public String getStaticResourceURL(
5116 HttpServletRequest request, String uri, long timestamp) {
5117
5118 return getStaticResourceURL(request, uri, null, timestamp);
5119 }
5120
5121 @Override
5122 public String getStaticResourceURL(
5123 HttpServletRequest request, String uri, String queryString) {
5124
5125 return getStaticResourceURL(request, uri, queryString, 0);
5126 }
5127
5128 @Override
5129 public String getStaticResourceURL(
5130 HttpServletRequest request, String uri, String queryString,
5131 long timestamp) {
5132
5133 if (uri.indexOf(CharPool.QUESTION) != -1) {
5134 return uri;
5135 }
5136
5137 if (uri.startsWith(StringPool.DOUBLE_SLASH)) {
5138 uri = uri.substring(1);
5139 }
5140
5141 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
5142 WebKeys.THEME_DISPLAY);
5143
5144 Theme theme = themeDisplay.getTheme();
5145 ColorScheme colorScheme = themeDisplay.getColorScheme();
5146
5147 Map<String, String[]> parameterMap = null;
5148
5149 if (Validator.isNotNull(queryString)) {
5150 parameterMap = HttpUtil.getParameterMap(queryString);
5151 }
5152
5153 StringBundler sb = new StringBundler(18);
5154
5155
5156
5157 sb.append(uri);
5158 sb.append(StringPool.QUESTION);
5159
5160
5161
5162 if ((parameterMap == null) || !parameterMap.containsKey("browserId")) {
5163 sb.append("&browserId=");
5164 sb.append(BrowserSnifferUtil.getBrowserId(request));
5165 }
5166
5167
5168
5169 if ((uri.endsWith(".css") || uri.endsWith(".jsp")) &&
5170 ((parameterMap == null) || !parameterMap.containsKey("themeId"))) {
5171
5172 sb.append("&themeId=");
5173 sb.append(HttpUtil.encodeURL(theme.getThemeId()));
5174 }
5175
5176 if (uri.endsWith(".jsp") &&
5177 ((parameterMap == null) ||
5178 !parameterMap.containsKey("colorSchemeId"))) {
5179
5180 sb.append("&colorSchemeId=");
5181 sb.append(HttpUtil.encodeURL(colorScheme.getColorSchemeId()));
5182 }
5183
5184
5185
5186 if ((parameterMap == null) ||
5187 !parameterMap.containsKey("minifierType")) {
5188
5189 String minifierType = StringPool.BLANK;
5190
5191 if (uri.endsWith(".css") || uri.endsWith("css.jsp") ||
5192 (uri.endsWith(".jsp") && uri.contains("/css/"))) {
5193
5194 if (themeDisplay.isThemeCssFastLoad()) {
5195 minifierType = "css";
5196 }
5197 }
5198 else if (themeDisplay.isThemeJsFastLoad()) {
5199 minifierType = "js";
5200 }
5201
5202 if (Validator.isNotNull(minifierType)) {
5203 sb.append("&minifierType=");
5204 sb.append(minifierType);
5205 }
5206 }
5207
5208
5209
5210 if (Validator.isNotNull(queryString)) {
5211 if (!queryString.startsWith(StringPool.AMPERSAND)) {
5212 sb.append(StringPool.AMPERSAND);
5213 }
5214
5215 sb.append(queryString);
5216 }
5217
5218
5219
5220 sb.append("&languageId=");
5221 sb.append(themeDisplay.getLanguageId());
5222
5223
5224
5225 sb.append("&b=");
5226 sb.append(ReleaseInfo.getBuildNumber());
5227
5228
5229
5230 if (((parameterMap == null) || !parameterMap.containsKey("t")) &&
5231 !(timestamp < 0)) {
5232
5233 if (timestamp == 0) {
5234 String portalURL = getPortalURL(request);
5235
5236 String path = StringUtil.replace(
5237 uri, portalURL, StringPool.BLANK);
5238
5239 if (path.startsWith(StrutsUtil.TEXT_HTML_DIR)) {
5240 ServletContext servletContext =
5241 (ServletContext)request.getAttribute(WebKeys.CTX);
5242
5243 timestamp = ServletContextUtil.getLastModified(
5244 servletContext, path, true);
5245 }
5246 else if (PortalWebResourcesUtil.hasContextPath(path)) {
5247 timestamp = PortalWebResourcesUtil.getLastModified(
5248 PortalWebResourcesUtil.getPathResourceType(path));
5249 }
5250 else {
5251 timestamp = theme.getTimestamp();
5252 }
5253 }
5254
5255 sb.append("&t=");
5256 sb.append(timestamp);
5257 }
5258
5259 String url = sb.toString();
5260
5261 url = StringUtil.replace(url, "?&", StringPool.QUESTION);
5262
5263 return url;
5264 }
5265
5266 @Override
5267 public String getStrutsAction(HttpServletRequest request) {
5268 String strutsAction = ParamUtil.getString(request, "struts_action");
5269
5270 if (Validator.isNotNull(strutsAction)) {
5271
5272
5273
5274
5275
5276 return StringPool.BLANK;
5277 }
5278
5279 return getPortletParam(request, "struts_action");
5280 }
5281
5282 @Override
5283 public String[] getSystemGroups() {
5284 return _allSystemGroups;
5285 }
5286
5287 @Override
5288 public String[] getSystemOrganizationRoles() {
5289 return _allSystemOrganizationRoles;
5290 }
5291
5292 @Override
5293 public String[] getSystemRoles() {
5294 return _allSystemRoles;
5295 }
5296
5297 @Override
5298 public String[] getSystemSiteRoles() {
5299 return _allSystemSiteRoles;
5300 }
5301
5302 @Override
5303 public String getUniqueElementId(
5304 HttpServletRequest request, String namespace, String elementId) {
5305
5306 String uniqueElementId = elementId;
5307
5308 Set<String> uniqueElementIds = (Set<String>)request.getAttribute(
5309 WebKeys.UNIQUE_ELEMENT_IDS);
5310
5311 if (uniqueElementIds == null) {
5312 uniqueElementIds = new ConcurrentHashSet<>();
5313
5314 request.setAttribute(WebKeys.UNIQUE_ELEMENT_IDS, uniqueElementIds);
5315 }
5316 else {
5317 int i = 1;
5318
5319 while (uniqueElementIds.contains(
5320 namespace.concat(uniqueElementId))) {
5321
5322 if (Validator.isNull(elementId) ||
5323 elementId.endsWith(StringPool.UNDERLINE)) {
5324
5325 uniqueElementId = elementId.concat(String.valueOf(i));
5326 }
5327 else {
5328 uniqueElementId =
5329 elementId.concat(StringPool.UNDERLINE).concat(
5330 String.valueOf(i));
5331 }
5332
5333 i++;
5334 }
5335 }
5336
5337 uniqueElementIds.add(namespace.concat(uniqueElementId));
5338
5339 return uniqueElementId;
5340 }
5341
5342 @Override
5343 public String getUniqueElementId(
5344 PortletRequest request, String namespace, String elementId) {
5345
5346 return getUniqueElementId(
5347 getHttpServletRequest(request), namespace, elementId);
5348 }
5349
5350 @Override
5351 public UploadPortletRequest getUploadPortletRequest(
5352 PortletRequest portletRequest) {
5353
5354 PortletRequestImpl portletRequestImpl =
5355 PortletRequestImpl.getPortletRequestImpl(portletRequest);
5356
5357 DynamicServletRequest dynamicRequest =
5358 (DynamicServletRequest)portletRequestImpl.getHttpServletRequest();
5359
5360 HttpServletRequestWrapper requestWrapper =
5361 (HttpServletRequestWrapper)dynamicRequest.getRequest();
5362
5363 UploadServletRequest uploadServletRequest = getUploadServletRequest(
5364 requestWrapper);
5365
5366 return new UploadPortletRequestImpl(
5367 uploadServletRequest, portletRequestImpl,
5368 getPortletNamespace(portletRequestImpl.getPortletName()));
5369 }
5370
5371 @Override
5372 public UploadServletRequest getUploadServletRequest(
5373 HttpServletRequest request) {
5374
5375 List<PersistentHttpServletRequestWrapper>
5376 persistentHttpServletRequestWrappers = new ArrayList<>();
5377
5378 HttpServletRequest currentRequest = request;
5379
5380 while (currentRequest instanceof HttpServletRequestWrapper) {
5381 if (currentRequest instanceof UploadServletRequest) {
5382 return (UploadServletRequest)currentRequest;
5383 }
5384
5385 Class<?> currentRequestClass = currentRequest.getClass();
5386
5387 String currentRequestClassName = currentRequestClass.getName();
5388
5389 if (!currentRequestClassName.startsWith("com.liferay.")) {
5390 break;
5391 }
5392
5393 if (currentRequest instanceof
5394 PersistentHttpServletRequestWrapper) {
5395
5396 PersistentHttpServletRequestWrapper
5397 persistentHttpServletRequestWrapper =
5398 (PersistentHttpServletRequestWrapper)currentRequest;
5399
5400 persistentHttpServletRequestWrappers.add(
5401 persistentHttpServletRequestWrapper.clone());
5402 }
5403
5404 HttpServletRequestWrapper httpServletRequestWrapper =
5405 (HttpServletRequestWrapper)currentRequest;
5406
5407 currentRequest =
5408 (HttpServletRequest)httpServletRequestWrapper.getRequest();
5409 }
5410
5411 if (ServerDetector.isWebLogic()) {
5412 currentRequest = new NonSerializableObjectRequestWrapper(
5413 currentRequest);
5414 }
5415
5416 for (int i = persistentHttpServletRequestWrappers.size() - 1; i >= 0;
5417 i--) {
5418
5419 HttpServletRequestWrapper httpServletRequestWrapper =
5420 persistentHttpServletRequestWrappers.get(i);
5421
5422 httpServletRequestWrapper.setRequest(currentRequest);
5423
5424 currentRequest = httpServletRequestWrapper;
5425 }
5426
5427 return new UploadServletRequestImpl(currentRequest);
5428 }
5429
5430 @Override
5431 public Date getUptime() {
5432 return _upTime;
5433 }
5434
5435 @Override
5436 public String getURLWithSessionId(String url, String sessionId) {
5437 if (!PropsValues.SESSION_ENABLE_URL_WITH_SESSION_ID) {
5438 return url;
5439 }
5440
5441 if (Validator.isNull(url)) {
5442 return url;
5443 }
5444
5445
5446
5447 int x = url.indexOf(CharPool.SEMICOLON);
5448
5449 if (x != -1) {
5450 return url;
5451 }
5452
5453 x = url.indexOf(CharPool.QUESTION);
5454
5455 if (x != -1) {
5456 StringBundler sb = new StringBundler(4);
5457
5458 sb.append(url.substring(0, x));
5459 sb.append(JSESSIONID);
5460 sb.append(sessionId);
5461 sb.append(url.substring(x));
5462
5463 return sb.toString();
5464 }
5465
5466
5467
5468
5469 x = url.indexOf(StringPool.DOUBLE_SLASH);
5470
5471 StringBundler sb = new StringBundler(4);
5472
5473 sb.append(url);
5474
5475 if (x != -1) {
5476 int y = url.lastIndexOf(CharPool.SLASH);
5477
5478 if ((x + 1) == y) {
5479 sb.append(StringPool.SLASH);
5480 }
5481 }
5482
5483 sb.append(JSESSIONID);
5484 sb.append(sessionId);
5485
5486 return sb.toString();
5487 }
5488
5489 @Override
5490 public User getUser(HttpServletRequest request) throws PortalException {
5491 User user = (User)request.getAttribute(WebKeys.USER);
5492
5493 if (user != null) {
5494 return user;
5495 }
5496
5497 long userId = getUserId(request);
5498
5499 if (userId <= 0) {
5500
5501
5502
5503
5504
5505
5506 String remoteUser = request.getRemoteUser();
5507
5508 if ((remoteUser == null) && !PropsValues.PORTAL_JAAS_ENABLE) {
5509 HttpSession session = request.getSession();
5510
5511 remoteUser = (String)session.getAttribute("j_remoteuser");
5512 }
5513
5514 if (remoteUser == null) {
5515 return null;
5516 }
5517
5518 if (PropsValues.PORTAL_JAAS_ENABLE) {
5519 long companyId = getCompanyId(request);
5520
5521 try {
5522 userId = JAASHelper.getJaasUserId(companyId, remoteUser);
5523 }
5524 catch (Exception e) {
5525 if (_log.isWarnEnabled()) {
5526 _log.warn(e, e);
5527 }
5528 }
5529 }
5530 else {
5531 userId = GetterUtil.getLong(remoteUser);
5532 }
5533 }
5534
5535 if (userId > 0) {
5536 user = UserLocalServiceUtil.getUserById(userId);
5537
5538 request.setAttribute(WebKeys.USER, user);
5539 }
5540
5541 Cookie[] cookies = request.getCookies();
5542
5543 if (cookies != null) {
5544 for (Cookie cookie : cookies) {
5545 String cookieName = cookie.getName();
5546
5547 if (cookieName.startsWith(
5548 CookieKeys.REMOTE_PREFERENCE_PREFIX)) {
5549
5550 user.addRemotePreference(
5551 new CookieRemotePreference(cookie));
5552 }
5553 }
5554 }
5555
5556 return user;
5557 }
5558
5559 @Override
5560 public User getUser(PortletRequest portletRequest) throws PortalException {
5561 return getUser(getHttpServletRequest(portletRequest));
5562 }
5563
5564 @Override
5565 public String getUserEmailAddress(long userId) {
5566 try {
5567 User user = UserLocalServiceUtil.getUserById(userId);
5568
5569 return user.getEmailAddress();
5570 }
5571 catch (PortalException pe) {
5572 return StringPool.BLANK;
5573 }
5574 }
5575
5576 @Override
5577 public long getUserId(HttpServletRequest request) {
5578 Long userIdObj = (Long)request.getAttribute(WebKeys.USER_ID);
5579
5580 if (userIdObj != null) {
5581 return userIdObj.longValue();
5582 }
5583
5584 String actionName = getPortletParam(request, "actionName");
5585 String mvcRenderCommandName = ParamUtil.getString(
5586 request, "mvcRenderCommandName");
5587 String path = GetterUtil.getString(request.getPathInfo());
5588 String strutsAction = getStrutsAction(request);
5589
5590 boolean alwaysAllowDoAsUser = false;
5591
5592 if (actionName.equals("addFile") ||
5593 mvcRenderCommandName.equals("/document_library/edit_file_entry") ||
5594 path.equals("/portal/session_click") ||
5595 isAlwaysAllowDoAsUser(
5596 actionName, mvcRenderCommandName, path, strutsAction)) {
5597
5598 try {
5599 alwaysAllowDoAsUser = isAlwaysAllowDoAsUser(request);
5600 }
5601 catch (Exception e) {
5602 _log.error(e, e);
5603 }
5604 }
5605
5606 if ((!PropsValues.PORTAL_JAAS_ENABLE &&
5607 PropsValues.PORTAL_IMPERSONATION_ENABLE) ||
5608 alwaysAllowDoAsUser) {
5609
5610 String doAsUserIdString = ParamUtil.getString(
5611 request, "doAsUserId");
5612
5613 try {
5614 long doAsUserId = getDoAsUserId(
5615 request, doAsUserIdString, alwaysAllowDoAsUser);
5616
5617 if (doAsUserId > 0) {
5618 if (_log.isDebugEnabled()) {
5619 _log.debug("Impersonating user " + doAsUserId);
5620 }
5621
5622 return doAsUserId;
5623 }
5624 }
5625 catch (Exception e) {
5626 _log.error("Unable to impersonate user " + doAsUserIdString, e);
5627 }
5628 }
5629
5630 HttpSession session = request.getSession();
5631
5632 userIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
5633
5634 if (userIdObj != null) {
5635 request.setAttribute(WebKeys.USER_ID, userIdObj);
5636
5637 return userIdObj.longValue();
5638 }
5639 else {
5640 return 0;
5641 }
5642 }
5643
5644 @Override
5645 public long getUserId(PortletRequest portletRequest) {
5646 return getUserId(getHttpServletRequest(portletRequest));
5647 }
5648
5649 @Override
5650 public String getUserName(BaseModel<?> baseModel) {
5651 long userId = 0;
5652 String userName = StringPool.BLANK;
5653
5654 if (baseModel instanceof AuditedModel) {
5655 AuditedModel auditedModel = (AuditedModel)baseModel;
5656
5657 userId = auditedModel.getUserId();
5658 userName = auditedModel.getUserName();
5659 }
5660 else {
5661 userId = BeanPropertiesUtil.getLongSilent(baseModel, "userId");
5662 userName = BeanPropertiesUtil.getStringSilent(
5663 baseModel, "userName");
5664 }
5665
5666 if (userId == 0) {
5667 return StringPool.BLANK;
5668 }
5669
5670 if (baseModel.isEscapedModel()) {
5671 userName = HtmlUtil.unescape(userName);
5672 }
5673
5674 userName = getUserName(userId, userName);
5675
5676 if (baseModel.isEscapedModel()) {
5677 userName = HtmlUtil.escape(userName);
5678 }
5679
5680 return userName;
5681 }
5682
5683 @Override
5684 public String getUserName(long userId, String defaultUserName) {
5685 return getUserName(
5686 userId, defaultUserName, UserAttributes.USER_NAME_FULL);
5687 }
5688
5689 @Override
5690 public String getUserName(
5691 long userId, String defaultUserName, HttpServletRequest request) {
5692
5693 return getUserName(
5694 userId, defaultUserName, UserAttributes.USER_NAME_FULL, request);
5695 }
5696
5697 @Override
5698 public String getUserName(
5699 long userId, String defaultUserName, String userAttribute) {
5700
5701 return getUserName(userId, defaultUserName, userAttribute, null);
5702 }
5703
5704 @Override
5705 public String getUserName(
5706 long userId, String defaultUserName, String userAttribute,
5707 HttpServletRequest request) {
5708
5709 String userName = defaultUserName;
5710
5711 try {
5712 User user = UserLocalServiceUtil.getUserById(userId);
5713
5714 if (userAttribute.equals(UserAttributes.USER_NAME_FULL)) {
5715 userName = user.getFullName();
5716 }
5717 else {
5718 userName = user.getScreenName();
5719 }
5720
5721 if (request != null) {
5722 Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
5723
5724 PortletURL portletURL = new PortletURLImpl(
5725 request, PortletKeys.DIRECTORY, layout.getPlid(),
5726 PortletRequest.RENDER_PHASE);
5727
5728 portletURL.setParameter(
5729 "struts_action", "/directory/view_user");
5730 portletURL.setParameter(
5731 "p_u_i_d", String.valueOf(user.getUserId()));
5732 portletURL.setPortletMode(PortletMode.VIEW);
5733 portletURL.setWindowState(WindowState.MAXIMIZED);
5734
5735 userName =
5736 "<a href=\"" + portletURL.toString() + "\">" +
5737 HtmlUtil.escape(userName) + "</a>";
5738 }
5739 }
5740 catch (Exception e) {
5741 }
5742
5743 return userName;
5744 }
5745
5746 @Override
5747 public String getUserPassword(HttpServletRequest request) {
5748 HttpSession session = request.getSession();
5749
5750 return getUserPassword(session);
5751 }
5752
5753 @Override
5754 public String getUserPassword(HttpSession session) {
5755 return (String)session.getAttribute(WebKeys.USER_PASSWORD);
5756 }
5757
5758 @Override
5759 public String getUserPassword(PortletRequest portletRequest) {
5760 return getUserPassword(getHttpServletRequest(portletRequest));
5761 }
5762
5763
5766 @Deprecated
5767 @Override
5768 public String getUserValue(long userId, String param, String defaultValue) {
5769 if (Validator.isNotNull(defaultValue)) {
5770 return defaultValue;
5771 }
5772
5773 try {
5774 User user = UserLocalServiceUtil.getUserById(userId);
5775
5776 return BeanPropertiesUtil.getString(user, param, defaultValue);
5777 }
5778 catch (PortalException pe) {
5779 return StringPool.BLANK;
5780 }
5781 }
5782
5783 @Override
5784 public String getValidPortalDomain(long companyId, String domain) {
5785 if (_validPortalDomainCheckDisabled) {
5786 return domain;
5787 }
5788
5789 for (String virtualHost : PropsValues.VIRTUAL_HOSTS_VALID_HOSTS) {
5790 if (StringUtil.equalsIgnoreCase(domain, virtualHost) ||
5791 StringUtil.wildcardMatches(
5792 domain, virtualHost, CharPool.QUESTION, CharPool.STAR,
5793 CharPool.PERCENT, false)) {
5794
5795 return domain;
5796 }
5797 }
5798
5799 if (_log.isWarnEnabled()) {
5800 _log.warn(
5801 "Set the property \"" + PropsKeys.VIRTUAL_HOSTS_VALID_HOSTS +
5802 "\" in portal.properties to allow \"" + domain +
5803 "\" as a domain");
5804 }
5805
5806 try {
5807 Company company = CompanyLocalServiceUtil.getCompanyById(
5808 getDefaultCompanyId());
5809
5810 return company.getVirtualHostname();
5811 }
5812 catch (Exception e) {
5813 _log.error("Unable to load default portal instance", e);
5814 }
5815
5816 return _LOCALHOST;
5817 }
5818
5819 @Override
5820 public long getValidUserId(long companyId, long userId)
5821 throws PortalException {
5822
5823 User user = UserLocalServiceUtil.fetchUser(userId);
5824
5825 if (user == null) {
5826 return UserLocalServiceUtil.getDefaultUserId(companyId);
5827 }
5828
5829 if (user.getCompanyId() == companyId) {
5830 return user.getUserId();
5831 }
5832
5833 return userId;
5834 }
5835
5836 @Override
5837 public String getVirtualHostname(LayoutSet layoutSet) {
5838 String virtualHostname = layoutSet.getVirtualHostname();
5839
5840 if (Validator.isNull(virtualHostname)) {
5841 virtualHostname = layoutSet.getCompanyFallbackVirtualHostname();
5842 }
5843
5844 return virtualHostname;
5845 }
5846
5847
5850 @Deprecated
5851 @Override
5852 public String getVirtualLayoutActualURL(
5853 long groupId, boolean privateLayout, String mainPath,
5854 String friendlyURL, Map<String, String[]> params,
5855 Map<String, Object> requestContext)
5856 throws PortalException {
5857
5858 FriendlyURLResolver friendlyURLResolver =
5859 FriendlyURLResolverRegistryUtil.getFriendlyURLResolver(
5860 VirtualLayoutConstants.CANONICAL_URL_SEPARATOR);
5861
5862 if (friendlyURLResolver == null) {
5863 return null;
5864 }
5865
5866 HttpServletRequest request = (HttpServletRequest)requestContext.get(
5867 "request");
5868
5869 long companyId = PortalInstances.getCompanyId(request);
5870
5871 return friendlyURLResolver.getActualURL(
5872 companyId, groupId, privateLayout, mainPath, friendlyURL, params,
5873 requestContext);
5874 }
5875
5876
5879 @Deprecated
5880 @Override
5881 public LayoutFriendlyURLComposite getVirtualLayoutFriendlyURLComposite(
5882 boolean privateLayout, String friendlyURL,
5883 Map<String, String[]> params, Map<String, Object> requestContext)
5884 throws PortalException {
5885
5886 FriendlyURLResolver friendlyURLResolver =
5887 FriendlyURLResolverRegistryUtil.getFriendlyURLResolver(
5888 VirtualLayoutConstants.CANONICAL_URL_SEPARATOR);
5889
5890 if (friendlyURLResolver == null) {
5891 return null;
5892 }
5893
5894 HttpServletRequest request = (HttpServletRequest)requestContext.get(
5895 "request");
5896
5897 long companyId = PortalInstances.getCompanyId(request);
5898
5899 return friendlyURLResolver.getLayoutFriendlyURLComposite(
5900 companyId, 0, privateLayout, friendlyURL, params, requestContext);
5901 }
5902
5903 @Override
5904 public String getWidgetURL(Portlet portlet, ThemeDisplay themeDisplay)
5905 throws PortalException {
5906
5907 return getServletURL(
5908 portlet, PropsValues.WIDGET_SERVLET_MAPPING, themeDisplay);
5909 }
5910
5911 @Override
5912 public void initCustomSQL() {
5913 _customSqlKeys = new String[] {
5914 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.GROUP$]",
5915 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.LAYOUT$]",
5916 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ORGANIZATION$]",
5917 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ROLE$]",
5918 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USER$]",
5919 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USERGROUP$]",
5920 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BLOGS.MODEL.BLOGSENTRY$]",
5921 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.DOCUMENTLIBRARY.MODEL." +
5922 "DLFILEENTRY$]",
5923 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.DOCUMENTLIBRARY.MODEL." +
5924 "DLFOLDER$]",
5925 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.MESSAGEBOARDS.MODEL." +
5926 "MBMESSAGE$]",
5927 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.MESSAGEBOARDS.MODEL." +
5928 "MBTHREAD$]",
5929 "[$RESOURCE_SCOPE_COMPANY$]", "[$RESOURCE_SCOPE_GROUP$]",
5930 "[$RESOURCE_SCOPE_GROUP_TEMPLATE$]",
5931 "[$RESOURCE_SCOPE_INDIVIDUAL$]",
5932 "[$SOCIAL_RELATION_TYPE_BI_COWORKER$]",
5933 "[$SOCIAL_RELATION_TYPE_BI_FRIEND$]",
5934 "[$SOCIAL_RELATION_TYPE_BI_ROMANTIC_PARTNER$]",
5935 "[$SOCIAL_RELATION_TYPE_BI_SIBLING$]",
5936 "[$SOCIAL_RELATION_TYPE_BI_SPOUSE$]",
5937 "[$SOCIAL_RELATION_TYPE_UNI_CHILD$]",
5938 "[$SOCIAL_RELATION_TYPE_UNI_ENEMY$]",
5939 "[$SOCIAL_RELATION_TYPE_UNI_FOLLOWER$]",
5940 "[$SOCIAL_RELATION_TYPE_UNI_PARENT$]",
5941 "[$SOCIAL_RELATION_TYPE_UNI_SUBORDINATE$]",
5942 "[$SOCIAL_RELATION_TYPE_UNI_SUPERVISOR$]", "[$FALSE$]", "[$TRUE$]"
5943 };
5944
5945 DB db = DBManagerUtil.getDB();
5946
5947 Object[] customSqlValues = new Object[] {
5948 getClassNameId(Group.class), getClassNameId(Layout.class),
5949 getClassNameId(Organization.class), getClassNameId(Role.class),
5950 getClassNameId(User.class), getClassNameId(UserGroup.class),
5951 getClassNameId(BlogsEntry.class), getClassNameId(DLFileEntry.class),
5952 getClassNameId(DLFolder.class), getClassNameId(MBMessage.class),
5953 getClassNameId(MBThread.class), ResourceConstants.SCOPE_COMPANY,
5954 ResourceConstants.SCOPE_GROUP,
5955 ResourceConstants.SCOPE_GROUP_TEMPLATE,
5956 ResourceConstants.SCOPE_INDIVIDUAL,
5957 SocialRelationConstants.TYPE_BI_COWORKER,
5958 SocialRelationConstants.TYPE_BI_FRIEND,
5959 SocialRelationConstants.TYPE_BI_ROMANTIC_PARTNER,
5960 SocialRelationConstants.TYPE_BI_SIBLING,
5961 SocialRelationConstants.TYPE_BI_SPOUSE,
5962 SocialRelationConstants.TYPE_UNI_CHILD,
5963 SocialRelationConstants.TYPE_UNI_ENEMY,
5964 SocialRelationConstants.TYPE_UNI_FOLLOWER,
5965 SocialRelationConstants.TYPE_UNI_PARENT,
5966 SocialRelationConstants.TYPE_UNI_SUBORDINATE,
5967 SocialRelationConstants.TYPE_UNI_SUPERVISOR, db.getTemplateFalse(),
5968 db.getTemplateTrue()
5969 };
5970
5971 _customSqlValues = ArrayUtil.toStringArray(customSqlValues);
5972 }
5973
5974 @Override
5975 public User initUser(HttpServletRequest request) throws Exception {
5976 User user = null;
5977
5978 try {
5979 user = getUser(request);
5980 }
5981 catch (NoSuchUserException nsue) {
5982 if (_log.isWarnEnabled()) {
5983 _log.warn(nsue.getMessage());
5984 }
5985
5986 long userId = getUserId(request);
5987
5988 if (userId > 0) {
5989 HttpSession session = request.getSession();
5990
5991 session.invalidate();
5992 }
5993
5994 throw nsue;
5995 }
5996
5997 if (user != null) {
5998 return user;
5999 }
6000
6001 Company company = getCompany(request);
6002
6003 return company.getDefaultUser();
6004 }
6005
6006
6009 @Deprecated
6010 @Override
6011 public void invokeTaglibDiscussion(
6012 PortletConfig portletConfig, ActionRequest actionRequest,
6013 ActionResponse actionResponse)
6014 throws Exception {
6015
6016 _editDiscussionStrutsAction.execute(
6017 getHttpServletRequest(actionRequest),
6018 getHttpServletResponse(actionResponse));
6019 }
6020
6021
6024 @Deprecated
6025 @Override
6026 public void invokeTaglibDiscussionPagination(
6027 PortletConfig portletConfig, ResourceRequest resourceRequest,
6028 ResourceResponse resourceResponse)
6029 throws IOException, PortletException {
6030
6031 try {
6032 _getCommentsStrutsAction.execute(
6033 getHttpServletRequest(resourceRequest),
6034 getHttpServletResponse(resourceResponse));
6035 }
6036 catch (IOException | PortletException | RuntimeException e) {
6037 throw e;
6038 }
6039 catch (Exception e) {
6040 throw new PortletException(e);
6041 }
6042 }
6043
6044
6047 @Deprecated
6048 @Override
6049 public boolean isAllowAddPortletDefaultResource(
6050 HttpServletRequest request, Portlet portlet)
6051 throws PortalException {
6052
6053 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
6054 WebKeys.THEME_DISPLAY);
6055
6056 Layout layout = themeDisplay.getLayout();
6057 LayoutTypePortlet layoutTypePortlet =
6058 themeDisplay.getLayoutTypePortlet();
6059
6060 String portletId = portlet.getPortletId();
6061
6062 Boolean renderPortletResource = (Boolean)request.getAttribute(
6063 WebKeys.RENDER_PORTLET_RESOURCE);
6064
6065 if (renderPortletResource != null) {
6066 boolean runtimePortlet = renderPortletResource.booleanValue();
6067
6068 if (runtimePortlet) {
6069 return true;
6070 }
6071 }
6072
6073 if (layout.isTypePanel() &&
6074 isPanelSelectedPortlet(themeDisplay, portletId)) {
6075
6076 return true;
6077 }
6078
6079 if (layout.isTypeControlPanel() &&
6080 isControlPanelPortlet(portletId, themeDisplay)) {
6081
6082 return true;
6083 }
6084
6085 if ((layoutTypePortlet != null) &&
6086 layoutTypePortlet.hasPortletId(portletId)) {
6087
6088 return true;
6089 }
6090
6091 if (themeDisplay.isSignedIn() &&
6092 portletId.equals(PortletKeys.LAYOUTS_ADMIN)) {
6093
6094 PermissionChecker permissionChecker =
6095 themeDisplay.getPermissionChecker();
6096
6097 Group group = layout.getGroup();
6098
6099 if (group.isSite()) {
6100 if (LayoutPermissionUtil.contains(
6101 permissionChecker, layout, ActionKeys.CUSTOMIZE) ||
6102 LayoutPermissionUtil.contains(
6103 permissionChecker, layout, ActionKeys.UPDATE)) {
6104
6105 return true;
6106 }
6107 }
6108
6109 if (group.isCompany()) {
6110 if (permissionChecker.isCompanyAdmin()) {
6111 return true;
6112 }
6113 }
6114 else if (group.isLayoutPrototype()) {
6115 long layoutPrototypeId = group.getClassPK();
6116
6117 if (LayoutPrototypePermissionUtil.contains(
6118 permissionChecker, layoutPrototypeId,
6119 ActionKeys.UPDATE)) {
6120
6121 return true;
6122 }
6123 }
6124 else if (group.isLayoutSetPrototype()) {
6125 long layoutSetPrototypeId = group.getClassPK();
6126
6127 if (LayoutSetPrototypePermissionUtil.contains(
6128 permissionChecker, layoutSetPrototypeId,
6129 ActionKeys.UPDATE)) {
6130
6131 return true;
6132 }
6133 }
6134 else if (group.isOrganization()) {
6135 long organizationId = group.getOrganizationId();
6136
6137 if (OrganizationPermissionUtil.contains(
6138 permissionChecker, organizationId, ActionKeys.UPDATE)) {
6139
6140 return true;
6141 }
6142 }
6143 else if (group.isUserGroup()) {
6144 long scopeGroupId = themeDisplay.getScopeGroupId();
6145
6146 if (GroupPermissionUtil.contains(
6147 permissionChecker, scopeGroupId, ActionKeys.UPDATE)) {
6148
6149 return true;
6150 }
6151 }
6152 else if (group.isUser()) {
6153 return true;
6154 }
6155 }
6156
6157 if (!portlet.isAddDefaultResource()) {
6158 return false;
6159 }
6160
6161 if (!PropsValues.PORTLET_ADD_DEFAULT_RESOURCE_CHECK_ENABLED) {
6162 return true;
6163 }
6164
6165 if (AuthTokenUtil.isValidPortletInvocationToken(
6166 request, layout, portlet)) {
6167
6168 return true;
6169 }
6170
6171 return false;
6172 }
6173
6174 @Override
6175 public boolean isCDNDynamicResourcesEnabled(HttpServletRequest request)
6176 throws PortalException {
6177
6178 Company company = getCompany(request);
6179
6180 return isCDNDynamicResourcesEnabled(company.getCompanyId());
6181 }
6182
6183 @Override
6184 public boolean isCDNDynamicResourcesEnabled(long companyId) {
6185 try {
6186 return PrefsPropsUtil.getBoolean(
6187 companyId, PropsKeys.CDN_DYNAMIC_RESOURCES_ENABLED,
6188 PropsValues.CDN_DYNAMIC_RESOURCES_ENABLED);
6189 }
6190 catch (SystemException se) {
6191 }
6192
6193 return PropsValues.CDN_DYNAMIC_RESOURCES_ENABLED;
6194 }
6195
6196
6199 @Deprecated
6200 @Override
6201 public boolean isCommunityAdmin(User user, long groupId) throws Exception {
6202 return isGroupAdmin(user, groupId);
6203 }
6204
6205
6208 @Deprecated
6209 @Override
6210 public boolean isCommunityOwner(User user, long groupId) throws Exception {
6211 return isGroupOwner(user, groupId);
6212 }
6213
6214 @Override
6215 public boolean isCompanyAdmin(User user) throws Exception {
6216 PermissionChecker permissionChecker =
6217 PermissionCheckerFactoryUtil.create(user);
6218
6219 return permissionChecker.isCompanyAdmin();
6220 }
6221
6222 @Override
6223 public boolean isCompanyControlPanelPortlet(
6224 String portletId, String category, ThemeDisplay themeDisplay)
6225 throws PortalException {
6226
6227 PermissionChecker permissionChecker =
6228 themeDisplay.getPermissionChecker();
6229
6230 if (permissionChecker.isCompanyAdmin()) {
6231 return true;
6232 }
6233
6234 Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
6235 themeDisplay.getCompanyId());
6236
6237 themeDisplay.setScopeGroupId(companyGroup.getGroupId());
6238
6239 return isControlPanelPortlet(portletId, category, themeDisplay);
6240 }
6241
6242 @Override
6243 public boolean isCompanyControlPanelPortlet(
6244 String portletId, ThemeDisplay themeDisplay)
6245 throws PortalException {
6246
6247 PermissionChecker permissionChecker =
6248 themeDisplay.getPermissionChecker();
6249
6250 if (permissionChecker.isCompanyAdmin()) {
6251 return true;
6252 }
6253
6254 Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
6255 themeDisplay.getCompanyId());
6256
6257 themeDisplay.setScopeGroupId(companyGroup.getGroupId());
6258
6259 return isControlPanelPortlet(portletId, themeDisplay);
6260 }
6261
6262 @Override
6263 public boolean isControlPanelPortlet(
6264 String portletId, String category, ThemeDisplay themeDisplay) {
6265
6266 Portlet portlet = PortletLocalServiceUtil.getPortletById(
6267 themeDisplay.getCompanyId(), portletId);
6268
6269 String controlPanelEntryCategory =
6270 portlet.getControlPanelEntryCategory();
6271
6272 if (controlPanelEntryCategory.equals(category) ||
6273 (category.endsWith(StringPool.PERIOD) &&
6274 StringUtil.startsWith(controlPanelEntryCategory, category))) {
6275
6276 return isControlPanelPortlet(portletId, themeDisplay);
6277 }
6278
6279 return false;
6280 }
6281
6282 @Override
6283 public boolean isControlPanelPortlet(
6284 String portletId, ThemeDisplay themeDisplay) {
6285
6286 try {
6287 return PortletPermissionUtil.hasControlPanelAccessPermission(
6288 themeDisplay.getPermissionChecker(),
6289 themeDisplay.getScopeGroupId(), portletId);
6290 }
6291 catch (PortalException pe) {
6292 if (_log.isWarnEnabled()) {
6293 _log.warn(
6294 "Unable to check control panel access permission", pe);
6295 }
6296 }
6297
6298 return false;
6299 }
6300
6301 @Override
6302 public boolean isGroupAdmin(User user, long groupId) throws Exception {
6303 PermissionChecker permissionChecker =
6304 PermissionCheckerFactoryUtil.create(user);
6305
6306 return permissionChecker.isGroupAdmin(groupId);
6307 }
6308
6309 @Override
6310 public boolean isGroupFriendlyURL(
6311 String fullURL, String groupFriendlyURL, String layoutFriendlyURL) {
6312
6313 if (fullURL.endsWith(groupFriendlyURL) &&
6314 !fullURL.endsWith(groupFriendlyURL.concat(layoutFriendlyURL))) {
6315
6316 return true;
6317 }
6318
6319 return false;
6320 }
6321
6322 @Override
6323 public boolean isGroupOwner(User user, long groupId) throws Exception {
6324 PermissionChecker permissionChecker =
6325 PermissionCheckerFactoryUtil.create(user);
6326
6327 return permissionChecker.isGroupOwner(groupId);
6328 }
6329
6330 @Override
6331 public boolean isLayoutDescendant(Layout layout, long layoutId)
6332 throws PortalException {
6333
6334 if (layout.getLayoutId() == layoutId) {
6335 return true;
6336 }
6337
6338 for (Layout childLayout : layout.getChildren()) {
6339 if (isLayoutDescendant(childLayout, layoutId)) {
6340 return true;
6341 }
6342 }
6343
6344 return false;
6345 }
6346
6347 @Override
6348 public boolean isLayoutSitemapable(Layout layout) {
6349 if (layout.isPrivateLayout()) {
6350 return false;
6351 }
6352
6353 LayoutType layoutType = layout.getLayoutType();
6354
6355 return layoutType.isSitemapable();
6356 }
6357
6358 @Override
6359 public boolean isLoginRedirectRequired(HttpServletRequest request) {
6360 if (PropsValues.COMPANY_SECURITY_AUTH_REQUIRES_HTTPS &&
6361 !request.isSecure()) {
6362
6363 return true;
6364 }
6365
6366 long companyId = getCompanyId(request);
6367
6368 if (SSOUtil.isLoginRedirectRequired(companyId)) {
6369 return true;
6370 }
6371
6372 return false;
6373 }
6374
6375 @Override
6376 public boolean isMethodGet(PortletRequest portletRequest) {
6377 HttpServletRequest request = getHttpServletRequest(portletRequest);
6378
6379 String method = GetterUtil.getString(request.getMethod());
6380
6381 if (StringUtil.equalsIgnoreCase(method, HttpMethods.GET)) {
6382 return true;
6383 }
6384 else {
6385 return false;
6386 }
6387 }
6388
6389 @Override
6390 public boolean isMethodPost(PortletRequest portletRequest) {
6391 HttpServletRequest request = getHttpServletRequest(portletRequest);
6392
6393 String method = GetterUtil.getString(request.getMethod());
6394
6395 if (StringUtil.equalsIgnoreCase(method, HttpMethods.POST)) {
6396 return true;
6397 }
6398 else {
6399 return false;
6400 }
6401 }
6402
6403 @Override
6404 public boolean isMultipartRequest(HttpServletRequest request) {
6405 String contentType = request.getHeader(HttpHeaders.CONTENT_TYPE);
6406
6407 if ((contentType != null) &&
6408 contentType.startsWith(ContentTypes.MULTIPART_FORM_DATA)) {
6409
6410 return true;
6411 }
6412 else {
6413 return false;
6414 }
6415 }
6416
6417 @Override
6418 public boolean isOmniadmin(long userId) {
6419 return OmniadminUtil.isOmniadmin(userId);
6420 }
6421
6422 @Override
6423 public boolean isOmniadmin(User user) {
6424 return OmniadminUtil.isOmniadmin(user);
6425 }
6426
6427 @Override
6428 public boolean isReservedParameter(String name) {
6429 return _reservedParams.contains(name);
6430 }
6431
6432 @Override
6433 public boolean isRightToLeft(HttpServletRequest request) {
6434 String languageId = LanguageUtil.getLanguageId(request);
6435
6436 Locale locale = LocaleUtil.fromLanguageId(languageId);
6437
6438 String langDir = LanguageUtil.get(locale, "lang.dir");
6439
6440 return langDir.equals("rtl");
6441 }
6442
6443 @Override
6444 public boolean isRSSFeedsEnabled() {
6445 return PropsValues.RSS_FEEDS_ENABLED;
6446 }
6447
6448 @Override
6449 public boolean isSecure(HttpServletRequest request) {
6450 HttpSession session = request.getSession();
6451
6452 if (session == null) {
6453 return request.isSecure();
6454 }
6455
6456 Boolean httpsInitial = (Boolean)session.getAttribute(
6457 WebKeys.HTTPS_INITIAL);
6458
6459 boolean secure = false;
6460
6461 if (PropsValues.COMPANY_SECURITY_AUTH_REQUIRES_HTTPS &&
6462 !PropsValues.SESSION_ENABLE_PHISHING_PROTECTION &&
6463 (httpsInitial != null) && !httpsInitial.booleanValue()) {
6464
6465 secure = false;
6466 }
6467 else {
6468 secure = request.isSecure();
6469 }
6470
6471 return secure;
6472 }
6473
6474 @Override
6475 public boolean isSystemGroup(String groupName) {
6476 if (groupName == null) {
6477 return false;
6478 }
6479
6480 groupName = groupName.trim();
6481
6482 int pos = Arrays.binarySearch(
6483 _sortedSystemGroups, groupName, new StringComparator());
6484
6485 if (pos >= 0) {
6486 return true;
6487 }
6488 else {
6489 return false;
6490 }
6491 }
6492
6493 @Override
6494 public boolean isSystemRole(String roleName) {
6495 if (roleName == null) {
6496 return false;
6497 }
6498
6499 roleName = roleName.trim();
6500
6501 int pos = Arrays.binarySearch(
6502 _sortedSystemRoles, roleName, new StringComparator());
6503
6504 if (pos >= 0) {
6505 return true;
6506 }
6507
6508 pos = Arrays.binarySearch(
6509 _sortedSystemSiteRoles, roleName, new StringComparator());
6510
6511 if (pos >= 0) {
6512 return true;
6513 }
6514
6515 pos = Arrays.binarySearch(
6516 _sortedSystemOrganizationRoles, roleName, new StringComparator());
6517
6518 if (pos >= 0) {
6519 return true;
6520 }
6521
6522 return false;
6523 }
6524
6525 @Override
6526 public boolean isUpdateAvailable() {
6527 return PluginPackageUtil.isUpdateAvailable();
6528 }
6529
6530 @Override
6531 public boolean isValidResourceId(String resourceId) {
6532 if (Validator.isNull(resourceId)) {
6533 return true;
6534 }
6535
6536 Matcher matcher = _bannedResourceIdPattern.matcher(resourceId);
6537
6538 if (matcher.matches()) {
6539 return false;
6540 }
6541
6542 return true;
6543 }
6544
6545 @Override
6546 public boolean removePortalInetSocketAddressEventListener(
6547 PortalInetSocketAddressEventListener
6548 portalInetSocketAddressEventListener) {
6549
6550 return _portalInetSocketAddressEventListeners.remove(
6551 portalInetSocketAddressEventListener);
6552 }
6553
6554
6559 @Deprecated
6560 @Override
6561 public void removePortalPortEventListener(
6562 PortalPortEventListener portalPortEventListener) {
6563
6564 _portalPortEventListeners.remove(portalPortEventListener);
6565 }
6566
6567 @Override
6568 public void resetCDNHosts() {
6569 _cdnHostHttpMap.clear();
6570 _cdnHostHttpsMap.clear();
6571
6572 if (!ClusterInvokeThreadLocal.isEnabled()) {
6573 return;
6574 }
6575
6576 ClusterRequest clusterRequest = ClusterRequest.createMulticastRequest(
6577 _resetCDNHostsMethodHandler, true);
6578
6579 try {
6580 ClusterExecutorUtil.execute(clusterRequest);
6581 }
6582 catch (Exception e) {
6583 _log.error("Unable to clear cluster wide CDN hosts", e);
6584 }
6585 }
6586
6587
6591 @Deprecated
6592 @Override
6593 public Set<String> resetPortletAddDefaultResourceCheckWhitelist() {
6594 return AuthTokenWhitelistUtil.resetPortletInvocationWhitelist();
6595 }
6596
6597
6601 @Deprecated
6602 @Override
6603 public Set<String> resetPortletAddDefaultResourceCheckWhitelistActions() {
6604 return AuthTokenWhitelistUtil.resetPortletInvocationWhitelistActions();
6605 }
6606
6607 @Override
6608 public String resetPortletParameters(String url, String portletId) {
6609 if (Validator.isNull(url) || Validator.isNull(portletId)) {
6610 return url;
6611 }
6612
6613 String portletNamespace = getPortletNamespace(portletId);
6614
6615 Map<String, String[]> parameterMap = HttpUtil.getParameterMap(url);
6616
6617 for (String name : parameterMap.keySet()) {
6618 if (name.startsWith(portletNamespace)) {
6619 url = HttpUtil.removeParameter(url, name);
6620 }
6621 }
6622
6623 return url;
6624 }
6625
6626 @Override
6627 public void sendError(
6628 Exception e, ActionRequest actionRequest,
6629 ActionResponse actionResponse)
6630 throws IOException {
6631
6632 sendError(0, e, actionRequest, actionResponse);
6633 }
6634
6635 @Override
6636 public void sendError(
6637 Exception e, HttpServletRequest request,
6638 HttpServletResponse response)
6639 throws IOException, ServletException {
6640
6641 sendError(0, e, request, response);
6642 }
6643
6644 @Override
6645 public void sendError(
6646 int status, Exception e, ActionRequest actionRequest,
6647 ActionResponse actionResponse)
6648 throws IOException {
6649
6650 StringBundler sb = new StringBundler(7);
6651
6652 sb.append(_pathMain);
6653 sb.append("/portal/status?status=");
6654 sb.append(status);
6655 sb.append("&exception=");
6656 sb.append(e.getClass().getName());
6657 sb.append("&previousURL=");
6658 sb.append(HttpUtil.encodeURL(getCurrentURL(actionRequest)));
6659
6660 actionResponse.sendRedirect(sb.toString());
6661 }
6662
6663 @Override
6664 public void sendError(
6665 int status, Exception e, HttpServletRequest request,
6666 HttpServletResponse response)
6667 throws IOException, ServletException {
6668
6669 if (_log.isDebugEnabled()) {
6670 String currentURL = (String)request.getAttribute(
6671 WebKeys.CURRENT_URL);
6672
6673 _log.debug(
6674 "Current URL " + currentURL + " generates exception: " +
6675 e.getMessage());
6676 }
6677
6678 if (e instanceof NoSuchImageException) {
6679 if (_logWebServerServlet.isWarnEnabled()) {
6680 _logWebServerServlet.warn(e, e);
6681 }
6682 }
6683 else if ((e instanceof PortalException) && _log.isDebugEnabled()) {
6684 if ((e instanceof NoSuchLayoutException) ||
6685 (e instanceof PrincipalException)) {
6686
6687 String msg = e.getMessage();
6688
6689 if (Validator.isNotNull(msg)) {
6690 _log.debug(msg);
6691 }
6692 }
6693 else {
6694 _log.debug(e, e);
6695 }
6696 }
6697 else if ((e instanceof SystemException) && _log.isWarnEnabled()) {
6698 _log.warn(e, e);
6699 }
6700
6701 if (response.isCommitted()) {
6702 return;
6703 }
6704
6705 if (status == 0) {
6706 if (e instanceof PrincipalException) {
6707 status = HttpServletResponse.SC_FORBIDDEN;
6708 }
6709 else {
6710 String name = e.getClass().getName();
6711
6712 name = name.substring(name.lastIndexOf(CharPool.PERIOD) + 1);
6713
6714 if (name.startsWith("NoSuch") && name.endsWith("Exception")) {
6715 status = HttpServletResponse.SC_NOT_FOUND;
6716 }
6717 }
6718
6719 if (status == 0) {
6720 status = HttpServletResponse.SC_BAD_REQUEST;
6721 }
6722 }
6723
6724 String redirect = null;
6725
6726 if ((e instanceof NoSuchGroupException) &&
6727 Validator.isNotNull(
6728 PropsValues.SITES_FRIENDLY_URL_PAGE_NOT_FOUND)) {
6729
6730 redirect = PropsValues.SITES_FRIENDLY_URL_PAGE_NOT_FOUND;
6731 }
6732 else if ((e instanceof NoSuchLayoutException) &&
6733 Validator.isNotNull(
6734 PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND)) {
6735
6736 redirect = PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND;
6737 }
6738 else if (PropsValues.LAYOUT_SHOW_HTTP_STATUS) {
6739 redirect = PATH_MAIN + "/portal/status";
6740 }
6741
6742 if (Validator.equals(redirect, request.getRequestURI())) {
6743 if (_log.isWarnEnabled()) {
6744 _log.warn("Unable to redirect to missing URI: " + redirect);
6745 }
6746
6747 redirect = null;
6748 }
6749
6750 if (Validator.isNotNull(redirect)) {
6751 HttpSession session = PortalSessionThreadLocal.getHttpSession();
6752
6753 if (session == null) {
6754 session = request.getSession();
6755 }
6756
6757 response.setStatus(status);
6758
6759 SessionErrors.add(session, e.getClass(), e);
6760
6761 ServletContext servletContext = session.getServletContext();
6762
6763 RequestDispatcher requestDispatcher =
6764 servletContext.getRequestDispatcher(redirect);
6765
6766 if (requestDispatcher != null) {
6767 requestDispatcher.forward(request, response);
6768 }
6769 }
6770 else if (e != null) {
6771 response.sendError(status, e.getMessage());
6772 }
6773 else {
6774 String currentURL = (String)request.getAttribute(
6775 WebKeys.CURRENT_URL);
6776
6777 response.sendError(status, "Current URL " + currentURL);
6778 }
6779 }
6780
6781 @Override
6782 public void sendRSSFeedsDisabledError(
6783 HttpServletRequest request, HttpServletResponse response)
6784 throws IOException, ServletException {
6785
6786 sendError(
6787 HttpServletResponse.SC_NOT_FOUND, new RSSFeedException(), request,
6788 response);
6789 }
6790
6791 @Override
6792 public void sendRSSFeedsDisabledError(
6793 PortletRequest portletRequest, PortletResponse portletResponse)
6794 throws IOException, ServletException {
6795
6796 HttpServletRequest request = getHttpServletRequest(portletRequest);
6797 HttpServletResponse response = getHttpServletResponse(portletResponse);
6798
6799 sendRSSFeedsDisabledError(request, response);
6800 }
6801
6802 @Override
6803 public void setPageDescription(
6804 String description, HttpServletRequest request) {
6805
6806 ListMergeable<String> descriptionListMergeable = new ListMergeable<>();
6807
6808 descriptionListMergeable.add(description);
6809
6810 request.setAttribute(
6811 WebKeys.PAGE_DESCRIPTION, descriptionListMergeable);
6812 }
6813
6814 @Override
6815 public void setPageKeywords(String keywords, HttpServletRequest request) {
6816 request.removeAttribute(WebKeys.PAGE_KEYWORDS);
6817
6818 addPageKeywords(keywords, request);
6819 }
6820
6821 @Override
6822 public void setPageSubtitle(String subtitle, HttpServletRequest request) {
6823 ListMergeable<String> subtitleListMergeable = new ListMergeable<>();
6824
6825 subtitleListMergeable.add(subtitle);
6826
6827 request.setAttribute(WebKeys.PAGE_SUBTITLE, subtitleListMergeable);
6828 }
6829
6830 @Override
6831 public void setPageTitle(String title, HttpServletRequest request) {
6832 ListMergeable<String> titleListMergeable = new ListMergeable<>();
6833
6834 titleListMergeable.add(title);
6835
6836 request.setAttribute(WebKeys.PAGE_TITLE, titleListMergeable);
6837 }
6838
6839 @Override
6840 public void setPortalInetSocketAddresses(HttpServletRequest request) {
6841 boolean secure = request.isSecure();
6842
6843 if ((secure && (_securePortalLocalInetSocketAddress.get() != null) &&
6844 (_securePortalServerInetSocketAddress.get() != null)) ||
6845 (!secure && (_portalLocalInetSocketAddress.get() != null) &&
6846 (_portalServerInetSocketAddress.get() != null))) {
6847
6848 return;
6849 }
6850
6851 InetAddress localInetAddress = null;
6852 InetAddress serverInetAddress = null;
6853
6854 try {
6855 localInetAddress = InetAddress.getByName(request.getLocalAddr());
6856 serverInetAddress = InetAddress.getByName(request.getServerName());
6857 }
6858 catch (UnknownHostException uhe) {
6859 if (_log.isWarnEnabled()) {
6860 _log.warn("Unable to resolve portal host", uhe);
6861 }
6862
6863 return;
6864 }
6865
6866 InetSocketAddress localInetSocketAddress = new InetSocketAddress(
6867 localInetAddress, request.getLocalPort());
6868 InetSocketAddress serverInetSocketAddress = new InetSocketAddress(
6869 serverInetAddress, request.getServerPort());
6870
6871 if (secure) {
6872 if (_securePortalLocalInetSocketAddress.compareAndSet(
6873 null, localInetSocketAddress)) {
6874
6875 notifyPortalInetSocketAddressEventListeners(
6876 localInetSocketAddress, true, true);
6877 }
6878
6879 if (_securePortalServerInetSocketAddress.compareAndSet(
6880 null, serverInetSocketAddress)) {
6881
6882 notifyPortalInetSocketAddressEventListeners(
6883 serverInetSocketAddress, false, true);
6884 }
6885 }
6886 else {
6887 if (_portalLocalInetSocketAddress.compareAndSet(
6888 null, localInetSocketAddress)) {
6889
6890 notifyPortalInetSocketAddressEventListeners(
6891 localInetSocketAddress, true, false);
6892 }
6893
6894 if (_portalServerInetSocketAddress.compareAndSet(
6895 null, serverInetSocketAddress)) {
6896
6897 notifyPortalInetSocketAddressEventListeners(
6898 serverInetSocketAddress, false, false);
6899 }
6900 }
6901 }
6902
6903
6909 @Deprecated
6910 @Override
6911 public void setPortalPort(HttpServletRequest request) {
6912 if (request.isSecure()) {
6913 if (_securePortalPort.get() == -1) {
6914 int securePortalPort = request.getServerPort();
6915
6916 if (_securePortalPort.compareAndSet(-1, securePortalPort) &&
6917 StringUtil.equalsIgnoreCase(
6918 Http.HTTPS, PropsValues.WEB_SERVER_PROTOCOL)) {
6919
6920 notifyPortalPortEventListeners(securePortalPort);
6921 }
6922 }
6923 }
6924 else {
6925 if (_portalPort.get() == -1) {
6926 int portalPort = request.getServerPort();
6927
6928 if (_portalPort.compareAndSet(-1, portalPort)) {
6929 notifyPortalPortEventListeners(portalPort);
6930 }
6931 }
6932 }
6933 }
6934
6935 @Override
6936 public void storePreferences(PortletPreferences portletPreferences)
6937 throws IOException, ValidatorException {
6938
6939 PortletPreferencesWrapper portletPreferencesWrapper =
6940 (PortletPreferencesWrapper)portletPreferences;
6941
6942 PortletPreferencesImpl portletPreferencesImpl =
6943 portletPreferencesWrapper.getPortletPreferencesImpl();
6944
6945 portletPreferencesImpl.store();
6946 }
6947
6948 @Override
6949 public String[] stripURLAnchor(String url, String separator) {
6950 String anchor = StringPool.BLANK;
6951
6952 int pos = url.indexOf(separator);
6953
6954 if (pos != -1) {
6955 anchor = url.substring(pos);
6956 url = url.substring(0, pos);
6957 }
6958
6959 return new String[] {url, anchor};
6960 }
6961
6962 @Override
6963 public String transformCustomSQL(String sql) {
6964 if ((_customSqlKeys == null) || (_customSqlValues == null)) {
6965 initCustomSQL();
6966 }
6967
6968 return StringUtil.replace(sql, _customSqlKeys, _customSqlValues);
6969 }
6970
6971 @Override
6972 public String transformSQL(String sql) {
6973 return SQLTransformer.transform(sql);
6974 }
6975
6976 @Override
6977 public void updateImageId(
6978 BaseModel<?> baseModel, boolean hasImage, byte[] bytes,
6979 String fieldName, long maxSize, int maxHeight, int maxWidth)
6980 throws PortalException {
6981
6982 long imageId = BeanPropertiesUtil.getLong(baseModel, fieldName);
6983
6984 if (!hasImage) {
6985 if (imageId > 0) {
6986 ImageLocalServiceUtil.deleteImage(imageId);
6987
6988 BeanPropertiesUtil.setProperty(baseModel, fieldName, 0);
6989 }
6990
6991 return;
6992 }
6993
6994 if (ArrayUtil.isEmpty(bytes)) {
6995 return;
6996 }
6997
6998 if ((maxSize > 0) && (bytes.length > maxSize)) {
6999 throw new ImageSizeException();
7000 }
7001
7002 if ((maxHeight > 0) || (maxWidth > 0)) {
7003 try {
7004 ImageBag imageBag = ImageToolUtil.read(bytes);
7005
7006 RenderedImage renderedImage = imageBag.getRenderedImage();
7007
7008 if (renderedImage == null) {
7009 throw new ImageTypeException();
7010 }
7011
7012 renderedImage = ImageToolUtil.scale(
7013 renderedImage, maxHeight, maxWidth);
7014
7015 bytes = ImageToolUtil.getBytes(
7016 renderedImage, imageBag.getType());
7017 }
7018 catch (IOException ioe) {
7019 throw new ImageSizeException(ioe);
7020 }
7021 }
7022
7023 Image image = ImageLocalServiceUtil.moveImage(imageId, bytes);
7024
7025 BeanPropertiesUtil.setProperty(
7026 baseModel, fieldName, image.getImageId());
7027 }
7028
7029 @Override
7030 public PortletMode updatePortletMode(
7031 String portletId, User user, Layout layout, PortletMode portletMode,
7032 HttpServletRequest request)
7033 throws PortalException {
7034
7035 LayoutTypePortlet layoutType =
7036 (LayoutTypePortlet)layout.getLayoutType();
7037
7038 if ((portletMode == null) || Validator.isNull(portletMode.toString())) {
7039 if (layoutType.hasModeAboutPortletId(portletId)) {
7040 return LiferayPortletMode.ABOUT;
7041 }
7042 else if (layoutType.hasModeConfigPortletId(portletId)) {
7043 return LiferayPortletMode.CONFIG;
7044 }
7045 else if (layoutType.hasModeEditPortletId(portletId)) {
7046 return PortletMode.EDIT;
7047 }
7048 else if (layoutType.hasModeEditDefaultsPortletId(portletId)) {
7049 return LiferayPortletMode.EDIT_DEFAULTS;
7050 }
7051 else if (layoutType.hasModeEditGuestPortletId(portletId)) {
7052 return LiferayPortletMode.EDIT_GUEST;
7053 }
7054 else if (layoutType.hasModeHelpPortletId(portletId)) {
7055 return PortletMode.HELP;
7056 }
7057 else if (layoutType.hasModePreviewPortletId(portletId)) {
7058 return LiferayPortletMode.PREVIEW;
7059 }
7060 else if (layoutType.hasModePrintPortletId(portletId)) {
7061 return LiferayPortletMode.PRINT;
7062 }
7063 else {
7064 return PortletMode.VIEW;
7065 }
7066 }
7067 else {
7068 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
7069 WebKeys.THEME_DISPLAY);
7070
7071 PermissionChecker permissionChecker =
7072 themeDisplay.getPermissionChecker();
7073
7074 Portlet portlet = PortletLocalServiceUtil.getPortletById(
7075 getCompanyId(request), portletId);
7076
7077 if (!PortletPermissionUtil.contains(
7078 permissionChecker, getScopeGroupId(request), layout,
7079 portlet, ActionKeys.VIEW)) {
7080
7081 return portletMode;
7082 }
7083
7084 boolean updateLayout = false;
7085
7086 if (portletMode.equals(LiferayPortletMode.ABOUT) &&
7087 !layoutType.hasModeAboutPortletId(portletId)) {
7088
7089 layoutType.addModeAboutPortletId(portletId);
7090
7091 updateLayout = true;
7092 }
7093 else if (portletMode.equals(LiferayPortletMode.CONFIG) &&
7094 !layoutType.hasModeConfigPortletId(portletId) &&
7095 PortletPermissionUtil.contains(
7096 permissionChecker, getScopeGroupId(request), layout,
7097 portlet, ActionKeys.CONFIGURATION)) {
7098
7099 layoutType.addModeConfigPortletId(portletId);
7100
7101 updateLayout = true;
7102 }
7103 else if (portletMode.equals(PortletMode.EDIT) &&
7104 !layoutType.hasModeEditPortletId(portletId) &&
7105 PortletPermissionUtil.contains(
7106 permissionChecker, getScopeGroupId(request), layout,
7107 portlet, ActionKeys.PREFERENCES)) {
7108
7109 layoutType.addModeEditPortletId(portletId);
7110
7111 updateLayout = true;
7112 }
7113 else if (portletMode.equals(LiferayPortletMode.EDIT_DEFAULTS) &&
7114 !layoutType.hasModeEditDefaultsPortletId(portletId) &&
7115 PortletPermissionUtil.contains(
7116 permissionChecker, getScopeGroupId(request), layout,
7117 portlet, ActionKeys.PREFERENCES)) {
7118
7119 layoutType.addModeEditDefaultsPortletId(portletId);
7120
7121 updateLayout = true;
7122 }
7123 else if (portletMode.equals(LiferayPortletMode.EDIT_GUEST) &&
7124 !layoutType.hasModeEditGuestPortletId(portletId) &&
7125 PortletPermissionUtil.contains(
7126 permissionChecker, getScopeGroupId(request), layout,
7127 portlet, ActionKeys.GUEST_PREFERENCES)) {
7128
7129 layoutType.addModeEditGuestPortletId(portletId);
7130
7131 updateLayout = true;
7132 }
7133 else if (portletMode.equals(PortletMode.HELP) &&
7134 !layoutType.hasModeHelpPortletId(portletId)) {
7135
7136 layoutType.addModeHelpPortletId(portletId);
7137
7138 updateLayout = true;
7139 }
7140 else if (portletMode.equals(LiferayPortletMode.PREVIEW) &&
7141 !layoutType.hasModePreviewPortletId(portletId)) {
7142
7143 layoutType.addModePreviewPortletId(portletId);
7144
7145 updateLayout = true;
7146 }
7147 else if (portletMode.equals(LiferayPortletMode.PRINT) &&
7148 !layoutType.hasModePrintPortletId(portletId)) {
7149
7150 layoutType.addModePrintPortletId(portletId);
7151
7152 updateLayout = true;
7153 }
7154 else if (portletMode.equals(PortletMode.VIEW) &&
7155 !layoutType.hasModeViewPortletId(portletId)) {
7156
7157 layoutType.removeModesPortletId(portletId);
7158
7159 updateLayout = true;
7160 }
7161
7162 if (updateLayout) {
7163 LayoutClone layoutClone = LayoutCloneFactory.getInstance();
7164
7165 if (layoutClone != null) {
7166 layoutClone.update(
7167 request, layout.getPlid(), layout.getTypeSettings());
7168 }
7169 }
7170
7171 return portletMode;
7172 }
7173 }
7174
7175 @Override
7176 public String updateRedirect(
7177 String redirect, String oldPath, String newPath) {
7178
7179 if (Validator.isNull(redirect) || (oldPath == null) ||
7180 oldPath.equals(newPath)) {
7181
7182 return redirect;
7183 }
7184
7185 String queryString = HttpUtil.getQueryString(redirect);
7186
7187 String redirectParam = HttpUtil.getParameter(
7188 redirect, "redirect", false);
7189
7190 if (Validator.isNotNull(redirectParam)) {
7191 String newRedirectParam = StringUtil.replace(
7192 redirectParam, HttpUtil.encodeURL(oldPath),
7193 HttpUtil.encodeURL(newPath));
7194
7195 queryString = StringUtil.replace(
7196 queryString, redirectParam, newRedirectParam);
7197 }
7198
7199 String redirectPath = HttpUtil.getPath(redirect);
7200
7201 int pos = redirect.indexOf(redirectPath);
7202
7203 String prefix = redirect.substring(0, pos);
7204
7205 pos = redirectPath.lastIndexOf(oldPath);
7206
7207 if (pos != -1) {
7208 prefix += redirectPath.substring(0, pos);
7209
7210 String suffix = redirectPath.substring(pos + oldPath.length());
7211
7212 redirect = prefix + newPath + suffix;
7213 }
7214 else {
7215 redirect = prefix + redirectPath;
7216 }
7217
7218 if (Validator.isNotNull(queryString)) {
7219 redirect += StringPool.QUESTION + queryString;
7220 }
7221
7222 return redirect;
7223 }
7224
7225 @Override
7226 public WindowState updateWindowState(
7227 String portletId, User user, Layout layout, WindowState windowState,
7228 HttpServletRequest request) {
7229
7230 LayoutTypePortlet layoutType =
7231 (LayoutTypePortlet)layout.getLayoutType();
7232
7233 if ((windowState == null) || Validator.isNull(windowState.toString())) {
7234 if (layoutType.hasStateMaxPortletId(portletId)) {
7235 windowState = WindowState.MAXIMIZED;
7236 }
7237 else if (layoutType.hasStateMinPortletId(portletId)) {
7238 windowState = WindowState.MINIMIZED;
7239 }
7240 else {
7241 windowState = WindowState.NORMAL;
7242 }
7243 }
7244 else {
7245 boolean updateLayout = false;
7246
7247 if (windowState.equals(WindowState.MAXIMIZED) &&
7248 !layoutType.hasStateMaxPortletId(portletId)) {
7249
7250 layoutType.addStateMaxPortletId(portletId);
7251
7252 if (PropsValues.LAYOUT_REMEMBER_MAXIMIZED_WINDOW_STATE) {
7253 updateLayout = true;
7254 }
7255 }
7256 else if (windowState.equals(WindowState.MINIMIZED) &&
7257 !layoutType.hasStateMinPortletId(portletId)) {
7258
7259 layoutType.addStateMinPortletId(portletId);
7260
7261 updateLayout = true;
7262 }
7263 else if (windowState.equals(WindowState.NORMAL) &&
7264 !layoutType.hasStateNormalPortletId(portletId)) {
7265
7266 layoutType.removeStatesPortletId(portletId);
7267
7268 updateLayout = true;
7269 }
7270
7271 if (updateLayout) {
7272 LayoutClone layoutClone = LayoutCloneFactory.getInstance();
7273
7274 if (layoutClone != null) {
7275 layoutClone.update(
7276 request, layout.getPlid(), layout.getTypeSettings());
7277 }
7278 }
7279 }
7280
7281 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
7282 WebKeys.THEME_DISPLAY);
7283
7284 themeDisplay.setStateExclusive(
7285 windowState.equals(LiferayWindowState.EXCLUSIVE));
7286 themeDisplay.setStateMaximized(
7287 windowState.equals(WindowState.MAXIMIZED));
7288 themeDisplay.setStatePopUp(
7289 windowState.equals(LiferayWindowState.POP_UP));
7290
7291 request.setAttribute(WebKeys.WINDOW_STATE, windowState);
7292
7293 return windowState;
7294 }
7295
7296 protected void addDefaultResource(
7297 long companyId, Layout layout, Portlet portlet,
7298 boolean portletActions)
7299 throws PortalException {
7300
7301 long groupId = getScopeGroupId(layout, portlet.getPortletId());
7302
7303 addDefaultResource(companyId, groupId, layout, portlet, portletActions);
7304 }
7305
7306 protected void addDefaultResource(
7307 long companyId, long groupId, Layout layout, Portlet portlet,
7308 boolean portletActions)
7309 throws PortalException {
7310
7311 String rootPortletId = portlet.getRootPortletId();
7312
7313 String portletPrimaryKey = PortletPermissionUtil.getPrimaryKey(
7314 layout.getPlid(), portlet.getPortletId());
7315
7316 String name = null;
7317 String primaryKey = null;
7318
7319 if (portletActions) {
7320 name = rootPortletId;
7321 primaryKey = portletPrimaryKey;
7322 }
7323 else {
7324 Group group = GroupLocalServiceUtil.fetchGroup(groupId);
7325
7326 if ((group != null) && group.isStagingGroup()) {
7327 groupId = group.getLiveGroupId();
7328 }
7329
7330 name = ResourceActionsUtil.getPortletBaseResource(rootPortletId);
7331 primaryKey = String.valueOf(groupId);
7332 }
7333
7334 if (Validator.isNull(name)) {
7335 return;
7336 }
7337
7338 int count =
7339 ResourcePermissionLocalServiceUtil.getResourcePermissionsCount(
7340 companyId, name, ResourceConstants.SCOPE_INDIVIDUAL,
7341 primaryKey);
7342
7343 if (count > 0) {
7344 return;
7345 }
7346
7347 boolean addGuestPermissions = true;
7348
7349 if (portletActions) {
7350 Group layoutGroup = layout.getGroup();
7351
7352 if (layout.isPrivateLayout() && !layoutGroup.isLayoutPrototype() &&
7353 !layoutGroup.isLayoutSetPrototype()) {
7354
7355 addGuestPermissions = false;
7356 }
7357 }
7358
7359 ResourceLocalServiceUtil.addResources(
7360 companyId, groupId, 0, name, primaryKey, portletActions, true,
7361 addGuestPermissions);
7362 }
7363
7364 protected String buildI18NPath(Locale locale) {
7365 String languageId = LocaleUtil.toLanguageId(locale);
7366
7367 if (Validator.isNull(languageId)) {
7368 return null;
7369 }
7370
7371 if (LanguageUtil.isDuplicateLanguageCode(locale.getLanguage())) {
7372 Locale priorityLocale = LanguageUtil.getLocale(
7373 locale.getLanguage());
7374
7375 if (locale.equals(priorityLocale)) {
7376 languageId = locale.getLanguage();
7377 }
7378 }
7379 else {
7380 languageId = locale.getLanguage();
7381 }
7382
7383 return StringPool.SLASH.concat(languageId);
7384 }
7385
7386 protected Set<Group> doGetAncestorSiteGroups(
7387 long groupId, boolean checkContentSharingWithChildrenEnabled)
7388 throws PortalException {
7389
7390 Set<Group> groups = new LinkedHashSet<>();
7391
7392 long siteGroupId = getSiteGroupId(groupId);
7393
7394 Group siteGroup = GroupLocalServiceUtil.fetchGroup(siteGroupId);
7395
7396 if (siteGroup == null) {
7397 return groups;
7398 }
7399
7400 for (Group group : siteGroup.getAncestors()) {
7401 if (checkContentSharingWithChildrenEnabled &&
7402 !SitesUtil.isContentSharingWithChildrenEnabled(group)) {
7403
7404 continue;
7405 }
7406
7407 groups.add(group);
7408 }
7409
7410 if (!siteGroup.isCompany()) {
7411 groups.add(
7412 GroupLocalServiceUtil.getCompanyGroup(
7413 siteGroup.getCompanyId()));
7414 }
7415
7416 return groups;
7417 }
7418
7419 protected Group doGetCurrentSiteGroup(long groupId) throws PortalException {
7420 long siteGroupId = getSiteGroupId(groupId);
7421
7422 Group siteGroup = GroupLocalServiceUtil.getGroup(siteGroupId);
7423
7424 if (!siteGroup.isLayoutPrototype()) {
7425 return siteGroup;
7426 }
7427
7428 return null;
7429 }
7430
7431 protected long doGetPlidFromPortletId(
7432 long groupId, boolean privateLayout, String portletId) {
7433
7434 long scopeGroupId = groupId;
7435
7436 try {
7437 Group group = GroupLocalServiceUtil.getGroup(groupId);
7438
7439 if (group.isLayout()) {
7440 Layout scopeLayout = LayoutLocalServiceUtil.getLayout(
7441 group.getClassPK());
7442
7443 groupId = scopeLayout.getGroupId();
7444 }
7445 }
7446 catch (Exception e) {
7447 }
7448
7449 long plid = LayoutConstants.DEFAULT_PLID;
7450
7451 List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
7452 groupId, privateLayout, LayoutConstants.TYPE_PORTLET);
7453
7454 for (Layout layout : layouts) {
7455 LayoutTypePortlet layoutTypePortlet =
7456 (LayoutTypePortlet)layout.getLayoutType();
7457
7458 if (layoutTypePortlet.hasPortletId(portletId, true)) {
7459 if (getScopeGroupId(layout, portletId) == scopeGroupId) {
7460 plid = layout.getPlid();
7461
7462 break;
7463 }
7464 }
7465 }
7466
7467 return plid;
7468 }
7469
7470 protected List<Portlet> filterControlPanelPortlets(
7471 Set<Portlet> portlets, ThemeDisplay themeDisplay) {
7472
7473 List<Portlet> filteredPortlets = new ArrayList<>(portlets);
7474
7475 Iterator<Portlet> itr = filteredPortlets.iterator();
7476
7477 while (itr.hasNext()) {
7478 Portlet portlet = itr.next();
7479
7480 try {
7481 if (!portlet.isActive() || portlet.isInstanceable() ||
7482 !PortletPermissionUtil.hasControlPanelAccessPermission(
7483 themeDisplay.getPermissionChecker(),
7484 themeDisplay.getScopeGroupId(), portlet)) {
7485
7486 itr.remove();
7487 }
7488 }
7489 catch (Exception e) {
7490 _log.error(e, e);
7491
7492 itr.remove();
7493 }
7494 }
7495
7496 return filteredPortlets;
7497 }
7498
7499 protected Locale getAvailableLocale(long groupId, Locale locale) {
7500 if (Validator.isNull(locale.getCountry())) {
7501
7502
7503
7504 locale = LanguageUtil.getLocale(locale.getLanguage());
7505 }
7506
7507 if (!LanguageUtil.isAvailableLocale(groupId, locale)) {
7508 return null;
7509 }
7510
7511 return locale;
7512 }
7513
7514 protected Layout getBrowsableLayout(Layout layout) {
7515 LayoutType layoutType = layout.getLayoutType();
7516
7517 if (layoutType.isBrowsable()) {
7518 return layout;
7519 }
7520
7521 Layout browsableChildLayout = null;
7522
7523 List<Layout> childLayouts = layout.getAllChildren();
7524
7525 for (Layout childLayout : childLayouts) {
7526 LayoutType childLayoutType = childLayout.getLayoutType();
7527
7528 if (childLayoutType.isBrowsable()) {
7529 browsableChildLayout = childLayout;
7530
7531 break;
7532 }
7533 }
7534
7535 if (browsableChildLayout != null) {
7536 return browsableChildLayout;
7537 }
7538
7539 long defaultPlid = LayoutLocalServiceUtil.getDefaultPlid(
7540 layout.getGroupId(), layout.getPrivateLayout());
7541
7542 return LayoutLocalServiceUtil.fetchLayout(defaultPlid);
7543 }
7544
7545 protected String getCanonicalDomain(
7546 String virtualHostname, String portalDomain) {
7547
7548 if (Validator.isBlank(portalDomain) ||
7549 StringUtil.equalsIgnoreCase(portalDomain, _LOCALHOST) ||
7550 !StringUtil.equalsIgnoreCase(virtualHostname, _LOCALHOST)) {
7551
7552 return virtualHostname;
7553 }
7554
7555 int pos = portalDomain.indexOf(CharPool.COLON);
7556
7557 if (pos == -1) {
7558 return portalDomain;
7559 }
7560
7561 return portalDomain.substring(0, pos);
7562 }
7563
7564 protected String getContextPath(String contextPath) {
7565 contextPath = GetterUtil.getString(contextPath);
7566
7567 if ((contextPath.length() == 0) ||
7568 contextPath.equals(StringPool.SLASH)) {
7569
7570 contextPath = StringPool.BLANK;
7571 }
7572 else if (!contextPath.startsWith(StringPool.SLASH)) {
7573 contextPath = StringPool.SLASH.concat(contextPath);
7574 }
7575
7576 return contextPath;
7577 }
7578
7579 protected Group getControlPanelDisplayGroup(
7580 long companyId, long scopeGroupId, long doAsGroupId, String portletId) {
7581
7582 Portlet portlet = PortletLocalServiceUtil.getPortletById(
7583 companyId, portletId);
7584
7585 String portletCategory = portlet.getControlPanelEntryCategory();
7586
7587 if (portletCategory.equals(
7588 PortletCategoryKeys.CONTROL_PANEL_APPS) ||
7589 portletCategory.equals(
7590 PortletCategoryKeys.CONTROL_PANEL_CONFIGURATION) ||
7591 portletCategory.equals(
7592 PortletCategoryKeys.CONTROL_PANEL_SITES) ||
7593 portletCategory.equals(
7594 PortletCategoryKeys.CONTROL_PANEL_SYSTEM) ||
7595 portletCategory.equals(
7596 PortletCategoryKeys.CONTROL_PANEL_USERS) ||
7597 portletCategory.equals(
7598 PortletCategoryKeys.USER_MY_ACCOUNT)) {
7599
7600 return GroupLocalServiceUtil.fetchGroup(
7601 companyId, GroupConstants.CONTROL_PANEL);
7602 }
7603 else {
7604 Group group = null;
7605
7606 if (doAsGroupId > 0) {
7607 group = GroupLocalServiceUtil.fetchGroup(doAsGroupId);
7608 }
7609
7610 if (group == null) {
7611 group = GroupLocalServiceUtil.fetchGroup(scopeGroupId);
7612 }
7613
7614 return group;
7615 }
7616 }
7617
7618 protected long getDoAsUserId(
7619 HttpServletRequest request, String doAsUserIdString,
7620 boolean alwaysAllowDoAsUser)
7621 throws Exception {
7622
7623 if (Validator.isNull(doAsUserIdString)) {
7624 return 0;
7625 }
7626
7627 long doAsUserId = 0;
7628
7629 try {
7630 Company company = getCompany(request);
7631
7632 doAsUserId = GetterUtil.getLong(
7633 Encryptor.decrypt(company.getKeyObj(), doAsUserIdString));
7634 }
7635 catch (Exception e) {
7636 if (_log.isWarnEnabled()) {
7637 _log.warn(
7638 "Unable to impersonate " + doAsUserIdString +
7639 " because the string cannot be decrypted");
7640 }
7641
7642 return 0;
7643 }
7644
7645 if (_log.isDebugEnabled()) {
7646 if (alwaysAllowDoAsUser) {
7647 _log.debug(
7648 "doAsUserId path or Struts action is always allowed");
7649 }
7650 else {
7651 _log.debug(
7652 "doAsUserId path is Struts action not always allowed");
7653 }
7654 }
7655
7656 if (alwaysAllowDoAsUser) {
7657 request.setAttribute(WebKeys.USER_ID, Long.valueOf(doAsUserId));
7658
7659 return doAsUserId;
7660 }
7661
7662 HttpSession session = request.getSession();
7663
7664 Long realUserIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
7665
7666 if (realUserIdObj == null) {
7667 return 0;
7668 }
7669
7670 User doAsUser = UserLocalServiceUtil.getUserById(doAsUserId);
7671
7672 long[] organizationIds = doAsUser.getOrganizationIds();
7673
7674 User realUser = UserLocalServiceUtil.getUserById(
7675 realUserIdObj.longValue());
7676
7677 PermissionChecker permissionChecker =
7678 PermissionCheckerFactoryUtil.create(realUser);
7679
7680 if (doAsUser.isDefaultUser() ||
7681 UserPermissionUtil.contains(
7682 permissionChecker, doAsUserId, organizationIds,
7683 ActionKeys.IMPERSONATE)) {
7684
7685 request.setAttribute(WebKeys.USER_ID, Long.valueOf(doAsUserId));
7686
7687 return doAsUserId;
7688 }
7689
7690 _log.error(
7691 "User " + realUserIdObj + " does not have the permission to " +
7692 "impersonate " + doAsUserId);
7693
7694 return 0;
7695 }
7696
7697 protected String getGroupFriendlyURL(
7698 LayoutSet layoutSet, ThemeDisplay themeDisplay,
7699 boolean canonicalURL)
7700 throws PortalException {
7701
7702 Group group = layoutSet.getGroup();
7703
7704 boolean privateLayoutSet = layoutSet.getPrivateLayout();
7705
7706 String portalURL = themeDisplay.getPortalURL();
7707
7708 boolean useGroupVirtualHostName = false;
7709
7710 if (canonicalURL ||
7711 !StringUtil.equalsIgnoreCase(
7712 themeDisplay.getServerName(), _LOCALHOST)) {
7713
7714 useGroupVirtualHostName = true;
7715 }
7716
7717 long refererPlid = themeDisplay.getRefererPlid();
7718
7719 if (refererPlid > 0) {
7720 Layout refererLayout = LayoutLocalServiceUtil.fetchLayout(
7721 refererPlid);
7722
7723 if ((refererLayout != null) &&
7724 ((refererLayout.getGroupId() != group.getGroupId()) ||
7725 (refererLayout.isPrivateLayout() != privateLayoutSet))) {
7726
7727 useGroupVirtualHostName = false;
7728 }
7729 }
7730
7731 if (useGroupVirtualHostName) {
7732 String virtualHostname = getVirtualHostname(layoutSet);
7733
7734 String portalDomain = HttpUtil.getDomain(portalURL);
7735
7736 if (Validator.isNotNull(virtualHostname) &&
7737 (canonicalURL ||
7738 !StringUtil.equalsIgnoreCase(virtualHostname, _LOCALHOST))) {
7739
7740 virtualHostname = getCanonicalDomain(
7741 virtualHostname, portalDomain);
7742
7743 virtualHostname = getPortalURL(
7744 virtualHostname, themeDisplay.getServerPort(),
7745 themeDisplay.isSecure());
7746
7747 if (canonicalURL || virtualHostname.contains(portalDomain)) {
7748 String path = StringPool.BLANK;
7749
7750 if (themeDisplay.isWidget()) {
7751 path = PropsValues.WIDGET_SERVLET_MAPPING;
7752 }
7753
7754 if (themeDisplay.isI18n() && !canonicalURL) {
7755 path = themeDisplay.getI18nPath();
7756 }
7757
7758 return virtualHostname.concat(_pathContext).concat(path);
7759 }
7760 }
7761 else {
7762 LayoutSet curLayoutSet = LayoutSetLocalServiceUtil.getLayoutSet(
7763 themeDisplay.getSiteGroupId(), privateLayoutSet);
7764
7765 if (canonicalURL ||
7766 ((layoutSet.getLayoutSetId() !=
7767 curLayoutSet.getLayoutSetId()) &&
7768 (group.getClassPK() != themeDisplay.getUserId()))) {
7769
7770 if (group.isControlPanel()) {
7771 virtualHostname = themeDisplay.getServerName();
7772
7773 if (Validator.isNull(virtualHostname) ||
7774 StringUtil.equalsIgnoreCase(
7775 virtualHostname, _LOCALHOST)) {
7776
7777 virtualHostname = curLayoutSet.getVirtualHostname();
7778 }
7779 }
7780
7781 if (Validator.isNull(virtualHostname) ||
7782 StringUtil.equalsIgnoreCase(
7783 virtualHostname, _LOCALHOST)) {
7784
7785 Company company = themeDisplay.getCompany();
7786
7787 virtualHostname = company.getVirtualHostname();
7788 }
7789
7790 if (canonicalURL ||
7791 !StringUtil.equalsIgnoreCase(
7792 virtualHostname, _LOCALHOST)) {
7793
7794 virtualHostname = getCanonicalDomain(
7795 virtualHostname, portalDomain);
7796
7797 portalURL = getPortalURL(
7798 virtualHostname, themeDisplay.getServerPort(),
7799 themeDisplay.isSecure());
7800 }
7801 }
7802 }
7803 }
7804
7805 String friendlyURL = null;
7806
7807 if (privateLayoutSet) {
7808 if (group.isUser()) {
7809 friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
7810 }
7811 else {
7812 friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
7813 }
7814 }
7815 else {
7816 friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
7817 }
7818
7819 StringBundler sb = new StringBundler(6);
7820
7821 sb.append(portalURL);
7822 sb.append(_pathContext);
7823
7824 if (themeDisplay.isI18n() && !canonicalURL) {
7825 sb.append(themeDisplay.getI18nPath());
7826 }
7827
7828 if (themeDisplay.isWidget()) {
7829 sb.append(PropsValues.WIDGET_SERVLET_MAPPING);
7830 }
7831
7832 sb.append(friendlyURL);
7833 sb.append(group.getFriendlyURL());
7834
7835 return sb.toString();
7836 }
7837
7838 protected String[] getGroupPermissions(
7839 String[] groupPermissions, String className,
7840 String inputPermissionsShowOptions) {
7841
7842 if ((groupPermissions != null) ||
7843 (inputPermissionsShowOptions != null)) {
7844
7845 return groupPermissions;
7846 }
7847
7848 List<String> groupDefaultActions =
7849 ResourceActionsUtil.getModelResourceGroupDefaultActions(className);
7850
7851 return groupDefaultActions.toArray(
7852 new String[groupDefaultActions.size()]);
7853 }
7854
7855 protected String[] getGuestPermissions(
7856 String[] guestPermissions, String className,
7857 String inputPermissionsShowOptions) {
7858
7859 if ((guestPermissions != null) ||
7860 (inputPermissionsShowOptions != null)) {
7861
7862 return guestPermissions;
7863 }
7864
7865 List<String> guestDefaultActions =
7866 ResourceActionsUtil.getModelResourceGuestDefaultActions(className);
7867
7868 return guestDefaultActions.toArray(
7869 new String[guestDefaultActions.size()]);
7870 }
7871
7872 protected String getPortletParam(HttpServletRequest request, String name) {
7873 String portletId = ParamUtil.getString(request, "p_p_id");
7874
7875 if (Validator.isNull(portletId)) {
7876 return StringPool.BLANK;
7877 }
7878
7879 String value = null;
7880
7881 int valueCount = 0;
7882
7883 String keyName = StringPool.UNDERLINE.concat(name);
7884
7885 Map<String, String[]> parameterMap = request.getParameterMap();
7886
7887 for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
7888 String parameterName = entry.getKey();
7889
7890 int pos = parameterName.indexOf(keyName);
7891
7892 if (pos == -1) {
7893 continue;
7894 }
7895
7896 valueCount++;
7897
7898
7899
7900 if (valueCount > 1) {
7901 return StringPool.BLANK;
7902 }
7903
7904 String[] parameterValues = entry.getValue();
7905
7906 if (ArrayUtil.isEmpty(parameterValues) ||
7907 Validator.isNull(parameterValues[0])) {
7908
7909 continue;
7910 }
7911
7912
7913
7914 String portletId1 = parameterName.substring(1, pos);
7915
7916 if (portletId.equals(portletId1)) {
7917 value = parameterValues[0];
7918 }
7919 }
7920
7921 if (value == null) {
7922 value = StringPool.BLANK;
7923 }
7924
7925 return value;
7926 }
7927
7928 protected String getServletURL(
7929 Portlet portlet, String servletPath, ThemeDisplay themeDisplay)
7930 throws PortalException {
7931
7932 Layout layout = themeDisplay.getLayout();
7933
7934 StringBundler sb = new StringBundler(9);
7935
7936 sb.append(themeDisplay.getPortalURL());
7937
7938 if (Validator.isNotNull(_pathContext)) {
7939 sb.append(_pathContext);
7940 }
7941
7942 if (themeDisplay.isI18n()) {
7943 sb.append(themeDisplay.getI18nPath());
7944 }
7945
7946 sb.append(servletPath);
7947
7948 Group group = layout.getGroup();
7949
7950 if (layout.isPrivateLayout()) {
7951 if (group.isUser()) {
7952 sb.append(_PRIVATE_USER_SERVLET_MAPPING);
7953 }
7954 else {
7955 sb.append(_PRIVATE_GROUP_SERVLET_MAPPING);
7956 }
7957 }
7958 else {
7959 sb.append(_PUBLIC_GROUP_SERVLET_MAPPING);
7960 }
7961
7962 sb.append(group.getFriendlyURL());
7963 sb.append(layout.getFriendlyURL(themeDisplay.getLocale()));
7964
7965 sb.append(FRIENDLY_URL_SEPARATOR);
7966
7967 FriendlyURLMapper friendlyURLMapper =
7968 portlet.getFriendlyURLMapperInstance();
7969
7970 if ((friendlyURLMapper != null) && !portlet.isInstanceable()) {
7971 sb.append(friendlyURLMapper.getMapping());
7972 }
7973 else {
7974 sb.append(portlet.getPortletId());
7975 }
7976
7977 return sb.toString();
7978 }
7979
7980 protected boolean isAlwaysAllowDoAsUser(HttpServletRequest request)
7981 throws Exception {
7982
7983 String ticketKey = ParamUtil.getString(request, "ticketKey");
7984
7985 if (Validator.isNull(ticketKey)) {
7986 return false;
7987 }
7988
7989 Ticket ticket = TicketLocalServiceUtil.fetchTicket(ticketKey);
7990
7991 if ((ticket == null) ||
7992 (ticket.getType() != TicketConstants.TYPE_IMPERSONATE)) {
7993
7994 return false;
7995 }
7996
7997 String className = ticket.getClassName();
7998
7999 if (!className.equals(User.class.getName())) {
8000 return false;
8001 }
8002
8003 long doAsUserId = 0;
8004
8005 try {
8006 Company company = getCompany(request);
8007
8008 String doAsUserIdString = ParamUtil.getString(
8009 request, "doAsUserId");
8010
8011 if (Validator.isNotNull(doAsUserIdString)) {
8012 doAsUserId = GetterUtil.getLong(
8013 Encryptor.decrypt(company.getKeyObj(), doAsUserIdString));
8014 }
8015 }
8016 catch (Exception e) {
8017 return false;
8018 }
8019
8020 if (ticket.getClassPK() != doAsUserId) {
8021 return false;
8022 }
8023
8024 if (ticket.isExpired()) {
8025 TicketLocalServiceUtil.deleteTicket(ticket);
8026
8027 return false;
8028 }
8029
8030 Date expirationDate = new Date(
8031 System.currentTimeMillis() +
8032 PropsValues.SESSION_TIMEOUT * Time.MINUTE);
8033
8034 ticket.setExpirationDate(expirationDate);
8035
8036 TicketLocalServiceUtil.updateTicket(ticket);
8037
8038 return true;
8039 }
8040
8041 protected boolean isAlwaysAllowDoAsUser(
8042 String actionName, String mvcRenderCommandName, String path,
8043 String strutsAction) {
8044
8045 for (AlwaysAllowDoAsUser alwaysAllowDoAsUser : _alwaysAllowDoAsUsers) {
8046 Collection<String> actionNames =
8047 alwaysAllowDoAsUser.getActionNames();
8048
8049 if (actionNames.contains(actionName)) {
8050 return true;
8051 }
8052
8053 Collection<String> mvcRenderCommandNames =
8054 alwaysAllowDoAsUser.getMVCRenderCommandNames();
8055
8056 if (mvcRenderCommandNames.contains(mvcRenderCommandName)) {
8057 return true;
8058 }
8059
8060 Collection<String> paths = alwaysAllowDoAsUser.getPaths();
8061
8062 if (paths.contains(path)) {
8063 return true;
8064 }
8065
8066 Collection<String> strutsActions =
8067 alwaysAllowDoAsUser.getStrutsActions();
8068
8069 if (strutsActions.contains(strutsAction)) {
8070 return true;
8071 }
8072 }
8073
8074 return false;
8075 }
8076
8077
8080 @Deprecated
8081 protected boolean isPanelSelectedPortlet(
8082 ThemeDisplay themeDisplay, String portletId) {
8083
8084 Layout layout = themeDisplay.getLayout();
8085
8086 String panelSelectedPortlets = layout.getTypeSettingsProperty(
8087 "panelSelectedPortlets");
8088
8089 if (Validator.isNotNull(panelSelectedPortlets)) {
8090 String[] panelSelectedPortletsArray = StringUtil.split(
8091 panelSelectedPortlets);
8092
8093 return ArrayUtil.contains(panelSelectedPortletsArray, portletId);
8094 }
8095
8096 return false;
8097 }
8098
8099 protected boolean isValidPortalDomain(long companyId, String domain) {
8100 if (_validPortalDomainCheckDisabled) {
8101 return true;
8102 }
8103
8104 if (!Validator.isHostName(domain)) {
8105 return false;
8106 }
8107
8108 for (String virtualHost : PropsValues.VIRTUAL_HOSTS_VALID_HOSTS) {
8109 if (StringUtil.equalsIgnoreCase(domain, virtualHost) ||
8110 StringUtil.wildcardMatches(
8111 domain, virtualHost, CharPool.QUESTION, CharPool.STAR,
8112 CharPool.PERCENT, false)) {
8113
8114 return true;
8115 }
8116 }
8117
8118 if (StringUtil.equalsIgnoreCase(domain, PropsValues.WEB_SERVER_HOST)) {
8119 return true;
8120 }
8121
8122 if (isValidVirtualHostname(domain)) {
8123 return true;
8124 }
8125
8126 if (StringUtil.equalsIgnoreCase(domain, getCDNHostHttp(companyId))) {
8127 return true;
8128 }
8129
8130 if (StringUtil.equalsIgnoreCase(domain, getCDNHostHttps(companyId))) {
8131 return true;
8132 }
8133
8134 return false;
8135 }
8136
8137 protected boolean isValidPortalDomain(String domain) {
8138 long companyId = CompanyThreadLocal.getCompanyId();
8139
8140 return isValidPortalDomain(companyId, domain);
8141 }
8142
8143 protected boolean isValidVirtualHostname(String virtualHostname) {
8144 try {
8145 virtualHostname = StringUtil.toLowerCase(virtualHostname.trim());
8146
8147 VirtualHost virtualHost =
8148 VirtualHostLocalServiceUtil.fetchVirtualHost(virtualHostname);
8149
8150 if (virtualHost != null) {
8151 return true;
8152 }
8153 }
8154 catch (Exception e) {
8155 }
8156
8157 return false;
8158 }
8159
8160 protected void notifyPortalInetSocketAddressEventListeners(
8161 InetSocketAddress inetSocketAddress, boolean local, boolean secure) {
8162
8163 for (PortalInetSocketAddressEventListener
8164 portalInetSocketAddressEventListener :
8165 _portalInetSocketAddressEventListeners) {
8166
8167 if (local) {
8168 portalInetSocketAddressEventListener.
8169 portalLocalInetSocketAddressConfigured(
8170 inetSocketAddress, secure);
8171 }
8172 else {
8173 portalInetSocketAddressEventListener.
8174 portalServerInetSocketAddressConfigured(
8175 inetSocketAddress, secure);
8176 }
8177 }
8178 }
8179
8180
8185 @Deprecated
8186 protected void notifyPortalPortEventListeners(int portalPort) {
8187 for (PortalPortEventListener portalPortEventListener :
8188 _portalPortEventListeners) {
8189
8190 portalPortEventListener.portalPortConfigured(portalPort);
8191 }
8192 }
8193
8194 protected String removeRedirectParameter(String url) {
8195 String queryString = HttpUtil.getQueryString(url);
8196
8197 Map<String, String[]> parameterMap = HttpUtil.getParameterMap(
8198 queryString);
8199
8200 for (String parameter : parameterMap.keySet()) {
8201 if (parameter.endsWith("redirect")) {
8202 url = HttpUtil.removeParameter(url, parameter);
8203 }
8204 }
8205
8206 return url;
8207 }
8208
8209 protected void resetThemeDisplayI18n(
8210 ThemeDisplay themeDisplay, String languageId, String path,
8211 Locale locale) {
8212
8213 themeDisplay.setI18nLanguageId(languageId);
8214 themeDisplay.setI18nPath(path);
8215 themeDisplay.setLocale(locale);
8216 }
8217
8218 protected void setLocale(
8219 HttpServletRequest request, HttpServletResponse response,
8220 Locale locale) {
8221
8222 HttpSession session = request.getSession();
8223
8224 session.setAttribute(Globals.LOCALE_KEY, locale);
8225
8226 LanguageUtil.updateCookie(request, response, locale);
8227 }
8228
8229 protected void setThemeDisplayI18n(
8230 ThemeDisplay themeDisplay, Locale locale) {
8231
8232 String i18nLanguageId = null;
8233 String i18nPath = null;
8234
8235 if ((I18nFilter.getLanguageIds().contains(locale.toString()) &&
8236 (PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 1) &&
8237 !locale.equals(LocaleUtil.getDefault())) ||
8238 (PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 2)) {
8239
8240 i18nLanguageId = locale.toString();
8241 i18nPath = buildI18NPath(locale);
8242 }
8243
8244 themeDisplay.setI18nLanguageId(i18nLanguageId);
8245 themeDisplay.setI18nPath(i18nPath);
8246 themeDisplay.setLocale(locale);
8247 }
8248
8249 private static final Log _logWebServerServlet = LogFactoryUtil.getLog(
8250 WebServerServlet.class);
8251
8252 private static final String _J_SECURITY_CHECK = "j_security_check";
8253
8254 private static final String _JOURNAL_ARTICLE_CANONICAL_URL_SEPARATOR =
8255 "/-/";
8256
8257 private static final String _LOCALHOST = "localhost";
8258
8259 private static final String _PRIVATE_GROUP_SERVLET_MAPPING =
8260 PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_GROUP_SERVLET_MAPPING;
8261
8262 private static final String _PRIVATE_USER_SERVLET_MAPPING =
8263 PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_USER_SERVLET_MAPPING;
8264
8265 private static final String _PUBLIC_GROUP_SERVLET_MAPPING =
8266 PropsValues.LAYOUT_FRIENDLY_URL_PUBLIC_SERVLET_MAPPING;
8267
8268 private static final Log _log = LogFactoryUtil.getLog(PortalImpl.class);
8269
8270 private static final Map<Long, String> _cdnHostHttpMap =
8271 new ConcurrentHashMap<>();
8272 private static final MethodHandler _resetCDNHostsMethodHandler =
8273 new MethodHandler(new MethodKey(PortalUtil.class, "resetCDNHosts"));
8274 private static final Date _upTime = new Date();
8275
8276 private final String[] _allSystemGroups;
8277 private final String[] _allSystemOrganizationRoles;
8278 private final String[] _allSystemRoles;
8279 private final String[] _allSystemSiteRoles;
8280 private final List<AlwaysAllowDoAsUser> _alwaysAllowDoAsUsers =
8281 new ArrayList<>();
8282 private final Pattern _bannedResourceIdPattern = Pattern.compile(
8283 PropsValues.PORTLET_RESOURCE_ID_BANNED_PATHS_REGEXP,
8284 Pattern.CASE_INSENSITIVE);
8285 private final Set<String> _computerAddresses = new HashSet<>();
8286 private final String _computerName;
8287 private String[] _customSqlKeys;
8288 private String[] _customSqlValues;
8289 private final EditDiscussionStrutsAction _editDiscussionStrutsAction =
8290 new EditDiscussionStrutsAction();
8291 private final GetCommentsStrutsAction _getCommentsStrutsAction =
8292 new GetCommentsStrutsAction();
8293 private final String _pathContext;
8294 private final String _pathFriendlyURLPrivateGroup;
8295 private final String _pathFriendlyURLPrivateUser;
8296 private final String _pathFriendlyURLPublic;
8297 private final String _pathImage;
8298 private final String _pathMain;
8299 private final String _pathModule;
8300 private final String _pathProxy;
8301 private final Map<String, Long> _plidToPortletIdMap =
8302 new ConcurrentHashMap<>();
8303 private final Set<PortalInetSocketAddressEventListener>
8304 _portalInetSocketAddressEventListeners = new CopyOnWriteArraySet<>();
8305 private final AtomicReference<InetSocketAddress>
8306 _portalLocalInetSocketAddress = new AtomicReference<>();
8307
8308
8312 @Deprecated
8313 private final AtomicInteger _portalPort = new AtomicInteger(-1);
8314
8315
8319 @Deprecated
8320 private final List<PortalPortEventListener> _portalPortEventListeners =
8321 new ArrayList<>();
8322
8323 private final AtomicReference<InetSocketAddress>
8324 _portalServerInetSocketAddress = new AtomicReference<>();
8325 private final Set<String> _reservedParams;
8326 private final AtomicReference<InetSocketAddress>
8327 _securePortalLocalInetSocketAddress = new AtomicReference<>();
8328
8329
8333 @Deprecated
8334 private final AtomicInteger _securePortalPort = new AtomicInteger(-1);
8335
8336 private final AtomicReference<InetSocketAddress>
8337 _securePortalServerInetSocketAddress = new AtomicReference<>();
8338 private final String _servletContextName;
8339 private final String[] _sortedSystemGroups;
8340 private final String[] _sortedSystemOrganizationRoles;
8341 private final String[] _sortedSystemRoles;
8342 private final String[] _sortedSystemSiteRoles;
8343 private final boolean _validPortalDomainCheckDisabled;
8344
8345 private class AlwaysAllowDoAsUserServiceTrackerCustomizer
8346 implements ServiceTrackerCustomizer
8347 <AlwaysAllowDoAsUser, AlwaysAllowDoAsUser> {
8348
8349 @Override
8350 public AlwaysAllowDoAsUser addingService(
8351 ServiceReference<AlwaysAllowDoAsUser> serviceReference) {
8352
8353 Registry registry = RegistryUtil.getRegistry();
8354
8355 AlwaysAllowDoAsUser alwaysAllowDoAsUser = registry.getService(
8356 serviceReference);
8357
8358 if (_log.isDebugEnabled()) {
8359 _log.debug(
8360 "Add alway sallow do as user " +
8361 ClassUtil.getClassName(alwaysAllowDoAsUser));
8362 }
8363
8364 _alwaysAllowDoAsUsers.add(alwaysAllowDoAsUser);
8365
8366 if (_log.isDebugEnabled()) {
8367 _log.debug(
8368 "There are " + _alwaysAllowDoAsUsers.size() +
8369 " alway sallow do as user instances");
8370 }
8371
8372 return alwaysAllowDoAsUser;
8373 }
8374
8375 @Override
8376 public void modifiedService(
8377 ServiceReference<AlwaysAllowDoAsUser> serviceReference,
8378 AlwaysAllowDoAsUser alwaysAllowDoAsUser) {
8379 }
8380
8381 @Override
8382 public void removedService(
8383 ServiceReference<AlwaysAllowDoAsUser> serviceReference,
8384 AlwaysAllowDoAsUser alwaysAllowDoAsUser) {
8385
8386 Registry registry = RegistryUtil.getRegistry();
8387
8388 registry.ungetService(serviceReference);
8389
8390 if (_log.isDebugEnabled()) {
8391 _log.debug(
8392 "Delete alway sallow do as user " +
8393 ClassUtil.getClassName(alwaysAllowDoAsUser));
8394 }
8395
8396 _alwaysAllowDoAsUsers.remove(alwaysAllowDoAsUser);
8397
8398 if (_log.isDebugEnabled()) {
8399 _log.debug(
8400 "There are " + _alwaysAllowDoAsUsers.size() +
8401 " alway sallow do as user instances");
8402 }
8403 }
8404
8405 }
8406
8407 private class PortalInetSocketAddressEventListenerServiceTrackerCustomizer
8408 implements ServiceTrackerCustomizer
8409 <PortalInetSocketAddressEventListener,
8410 PortalInetSocketAddressEventListener> {
8411
8412 @Override
8413 public PortalInetSocketAddressEventListener addingService(
8414 ServiceReference<PortalInetSocketAddressEventListener>
8415 serviceReference) {
8416
8417 Registry registry = RegistryUtil.getRegistry();
8418
8419 PortalInetSocketAddressEventListener
8420 portalInetSocketAddressEventListener = registry.getService(
8421 serviceReference);
8422
8423 addPortalInetSocketAddressEventListener(
8424 portalInetSocketAddressEventListener);
8425
8426 return portalInetSocketAddressEventListener;
8427 }
8428
8429 @Override
8430 public void modifiedService(
8431 ServiceReference<PortalInetSocketAddressEventListener>
8432 serviceReference,
8433 PortalInetSocketAddressEventListener
8434 portalInetSocketAddressEventListener) {
8435 }
8436
8437 @Override
8438 public void removedService(
8439 ServiceReference<PortalInetSocketAddressEventListener>
8440 serviceReference,
8441 PortalInetSocketAddressEventListener
8442 portalInetSocketAddressEventListener) {
8443
8444 Registry registry = RegistryUtil.getRegistry();
8445
8446 registry.ungetService(serviceReference);
8447
8448 removePortalInetSocketAddressEventListener(
8449 portalInetSocketAddressEventListener);
8450 }
8451
8452 }
8453
8454 private static final Map<Long, String> _cdnHostHttpsMap =
8455 new ConcurrentHashMap<>();
8456
8457 }