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