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