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