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