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