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