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