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