001
014
015 package com.liferay.portal.util;
016
017 import com.liferay.portal.NoSuchGroupException;
018 import com.liferay.portal.NoSuchImageException;
019 import com.liferay.portal.NoSuchLayoutException;
020 import com.liferay.portal.NoSuchUserException;
021 import com.liferay.portal.dao.orm.common.SQLTransformer;
022 import com.liferay.portal.kernel.bean.BeanPropertiesUtil;
023 import com.liferay.portal.kernel.cluster.ClusterExecutorUtil;
024 import com.liferay.portal.kernel.cluster.ClusterInvokeThreadLocal;
025 import com.liferay.portal.kernel.cluster.ClusterRequest;
026 import com.liferay.portal.kernel.concurrent.ConcurrentHashSet;
027 import com.liferay.portal.kernel.dao.db.DB;
028 import com.liferay.portal.kernel.dao.db.DBFactoryUtil;
029 import com.liferay.portal.kernel.dao.orm.QueryUtil;
030 import com.liferay.portal.kernel.exception.PortalException;
031 import com.liferay.portal.kernel.exception.SystemException;
032 import com.liferay.portal.kernel.language.LanguageUtil;
033 import com.liferay.portal.kernel.log.Log;
034 import com.liferay.portal.kernel.log.LogFactoryUtil;
035 import com.liferay.portal.kernel.portlet.FriendlyURLMapper;
036 import com.liferay.portal.kernel.portlet.FriendlyURLMapperThreadLocal;
037 import com.liferay.portal.kernel.portlet.LiferayPortletConfig;
038 import com.liferay.portal.kernel.portlet.LiferayPortletMode;
039 import com.liferay.portal.kernel.portlet.LiferayPortletRequest;
040 import com.liferay.portal.kernel.portlet.LiferayPortletResponse;
041 import com.liferay.portal.kernel.portlet.LiferayPortletURL;
042 import com.liferay.portal.kernel.portlet.LiferayWindowState;
043 import com.liferay.portal.kernel.portlet.PortletBag;
044 import com.liferay.portal.kernel.portlet.PortletBagPool;
045 import com.liferay.portal.kernel.security.pacl.DoPrivileged;
046 import com.liferay.portal.kernel.servlet.BrowserSnifferUtil;
047 import com.liferay.portal.kernel.servlet.DynamicServletRequest;
048 import com.liferay.portal.kernel.servlet.HttpHeaders;
049 import com.liferay.portal.kernel.servlet.HttpMethods;
050 import com.liferay.portal.kernel.servlet.NonSerializableObjectRequestWrapper;
051 import com.liferay.portal.kernel.servlet.PersistentHttpServletRequestWrapper;
052 import com.liferay.portal.kernel.servlet.PortalMessages;
053 import com.liferay.portal.kernel.servlet.PortalSessionThreadLocal;
054 import com.liferay.portal.kernel.servlet.ServletContextUtil;
055 import com.liferay.portal.kernel.servlet.SessionErrors;
056 import com.liferay.portal.kernel.servlet.taglib.ui.BreadcrumbEntry;
057 import com.liferay.portal.kernel.upload.UploadPortletRequest;
058 import com.liferay.portal.kernel.upload.UploadServletRequest;
059 import com.liferay.portal.kernel.util.ArrayUtil;
060 import com.liferay.portal.kernel.util.Base64;
061 import com.liferay.portal.kernel.util.CalendarFactoryUtil;
062 import com.liferay.portal.kernel.util.CharPool;
063 import com.liferay.portal.kernel.util.ContentTypes;
064 import com.liferay.portal.kernel.util.ContextPathUtil;
065 import com.liferay.portal.kernel.util.CookieKeys;
066 import com.liferay.portal.kernel.util.DeterminateKeyGenerator;
067 import com.liferay.portal.kernel.util.GetterUtil;
068 import com.liferay.portal.kernel.util.HtmlUtil;
069 import com.liferay.portal.kernel.util.Http;
070 import com.liferay.portal.kernel.util.HttpUtil;
071 import com.liferay.portal.kernel.util.InheritableMap;
072 import com.liferay.portal.kernel.util.JavaConstants;
073 import com.liferay.portal.kernel.util.ListMergeable;
074 import com.liferay.portal.kernel.util.ListUtil;
075 import com.liferay.portal.kernel.util.LocaleUtil;
076 import com.liferay.portal.kernel.util.LocalizationUtil;
077 import com.liferay.portal.kernel.util.MethodHandler;
078 import com.liferay.portal.kernel.util.MethodKey;
079 import com.liferay.portal.kernel.util.ParamUtil;
080 import com.liferay.portal.kernel.util.PropsKeys;
081 import com.liferay.portal.kernel.util.ReleaseInfo;
082 import com.liferay.portal.kernel.util.ResourceBundleUtil;
083 import com.liferay.portal.kernel.util.ServerDetector;
084 import com.liferay.portal.kernel.util.StringBundler;
085 import com.liferay.portal.kernel.util.StringComparator;
086 import com.liferay.portal.kernel.util.StringPool;
087 import com.liferay.portal.kernel.util.StringUtil;
088 import com.liferay.portal.kernel.util.Time;
089 import com.liferay.portal.kernel.util.UnicodeProperties;
090 import com.liferay.portal.kernel.util.UniqueList;
091 import com.liferay.portal.kernel.util.Validator;
092 import com.liferay.portal.kernel.xml.QName;
093 import com.liferay.portal.model.AuditedModel;
094 import com.liferay.portal.model.BaseModel;
095 import com.liferay.portal.model.ClassName;
096 import com.liferay.portal.model.ColorScheme;
097 import com.liferay.portal.model.Company;
098 import com.liferay.portal.model.Group;
099 import com.liferay.portal.model.GroupConstants;
100 import com.liferay.portal.model.Layout;
101 import com.liferay.portal.model.LayoutConstants;
102 import com.liferay.portal.model.LayoutFriendlyURLComposite;
103 import com.liferay.portal.model.LayoutQueryStringComposite;
104 import com.liferay.portal.model.LayoutSet;
105 import com.liferay.portal.model.LayoutType;
106 import com.liferay.portal.model.LayoutTypePortlet;
107 import com.liferay.portal.model.LayoutTypePortletConstants;
108 import com.liferay.portal.model.Organization;
109 import com.liferay.portal.model.Portlet;
110 import com.liferay.portal.model.PortletConstants;
111 import com.liferay.portal.model.PublicRenderParameter;
112 import com.liferay.portal.model.ResourceConstants;
113 import com.liferay.portal.model.ResourcePermission;
114 import com.liferay.portal.model.Role;
115 import com.liferay.portal.model.RoleConstants;
116 import com.liferay.portal.model.Theme;
117 import com.liferay.portal.model.Ticket;
118 import com.liferay.portal.model.TicketConstants;
119 import com.liferay.portal.model.User;
120 import com.liferay.portal.model.UserGroup;
121 import com.liferay.portal.model.VirtualHost;
122 import com.liferay.portal.model.VirtualLayoutConstants;
123 import com.liferay.portal.model.impl.CookieRemotePreference;
124 import com.liferay.portal.model.impl.LayoutTypePortletImpl;
125 import com.liferay.portal.model.impl.VirtualLayout;
126 import com.liferay.portal.plugin.PluginPackageUtil;
127 import com.liferay.portal.security.auth.AuthException;
128 import com.liferay.portal.security.auth.AuthTokenUtil;
129 import com.liferay.portal.security.auth.AuthTokenWhitelistUtil;
130 import com.liferay.portal.security.auth.CompanyThreadLocal;
131 import com.liferay.portal.security.auth.FullNameGenerator;
132 import com.liferay.portal.security.auth.FullNameGeneratorFactory;
133 import com.liferay.portal.security.auth.PrincipalException;
134 import com.liferay.portal.security.lang.DoPrivilegedUtil;
135 import com.liferay.portal.security.permission.ActionKeys;
136 import com.liferay.portal.security.permission.PermissionChecker;
137 import com.liferay.portal.security.permission.PermissionCheckerFactoryUtil;
138 import com.liferay.portal.security.permission.ResourceActionsUtil;
139 import com.liferay.portal.service.ClassNameLocalServiceUtil;
140 import com.liferay.portal.service.CompanyLocalServiceUtil;
141 import com.liferay.portal.service.GroupLocalServiceUtil;
142 import com.liferay.portal.service.GroupServiceUtil;
143 import com.liferay.portal.service.LayoutLocalServiceUtil;
144 import com.liferay.portal.service.LayoutSetLocalServiceUtil;
145 import com.liferay.portal.service.PortletLocalServiceUtil;
146 import com.liferay.portal.service.ResourceLocalServiceUtil;
147 import com.liferay.portal.service.ResourcePermissionLocalServiceUtil;
148 import com.liferay.portal.service.TicketLocalServiceUtil;
149 import com.liferay.portal.service.UserLocalServiceUtil;
150 import com.liferay.portal.service.UserServiceUtil;
151 import com.liferay.portal.service.VirtualHostLocalServiceUtil;
152 import com.liferay.portal.service.permission.GroupPermissionUtil;
153 import com.liferay.portal.service.permission.LayoutPermissionUtil;
154 import com.liferay.portal.service.permission.LayoutPrototypePermissionUtil;
155 import com.liferay.portal.service.permission.LayoutSetPrototypePermissionUtil;
156 import com.liferay.portal.service.permission.OrganizationPermissionUtil;
157 import com.liferay.portal.service.permission.PortletPermissionUtil;
158 import com.liferay.portal.service.permission.UserPermissionUtil;
159 import com.liferay.portal.servlet.filters.i18n.I18nFilter;
160 import com.liferay.portal.servlet.filters.secure.NonceUtil;
161 import com.liferay.portal.spring.context.PortalContextLoaderListener;
162 import com.liferay.portal.struts.StrutsUtil;
163 import com.liferay.portal.theme.PortletDisplay;
164 import com.liferay.portal.theme.ThemeDisplay;
165 import com.liferay.portal.upload.UploadPortletRequestImpl;
166 import com.liferay.portal.upload.UploadServletRequestImpl;
167 import com.liferay.portal.util.comparator.PortletControlPanelWeightComparator;
168 import com.liferay.portal.webserver.WebServerServlet;
169 import com.liferay.portlet.ActionResponseImpl;
170 import com.liferay.portlet.InvokerPortlet;
171 import com.liferay.portlet.PortletConfigFactoryUtil;
172 import com.liferay.portlet.PortletInstanceFactoryUtil;
173 import com.liferay.portlet.PortletPreferencesFactoryUtil;
174 import com.liferay.portlet.PortletPreferencesImpl;
175 import com.liferay.portlet.PortletPreferencesWrapper;
176 import com.liferay.portlet.PortletQNameUtil;
177 import com.liferay.portlet.PortletRequestImpl;
178 import com.liferay.portlet.PortletResponseImpl;
179 import com.liferay.portlet.PortletURLFactoryUtil;
180 import com.liferay.portlet.PortletURLImpl;
181 import com.liferay.portlet.RenderRequestImpl;
182 import com.liferay.portlet.RenderResponseImpl;
183 import com.liferay.portlet.StateAwareResponseImpl;
184 import com.liferay.portlet.UserAttributes;
185 import com.liferay.portlet.admin.util.OmniadminUtil;
186 import com.liferay.portlet.asset.model.AssetTag;
187 import com.liferay.portlet.asset.service.AssetTagLocalServiceUtil;
188 import com.liferay.portlet.blogs.model.BlogsEntry;
189 import com.liferay.portlet.bookmarks.model.BookmarksEntry;
190 import com.liferay.portlet.bookmarks.model.BookmarksFolder;
191 import com.liferay.portlet.calendar.model.CalEvent;
192 import com.liferay.portlet.documentlibrary.model.DLFileEntry;
193 import com.liferay.portlet.documentlibrary.model.DLFolder;
194 import com.liferay.portlet.expando.ValueDataException;
195 import com.liferay.portlet.expando.model.ExpandoBridge;
196 import com.liferay.portlet.expando.model.ExpandoColumnConstants;
197 import com.liferay.portlet.journal.NoSuchFeedException;
198 import com.liferay.portlet.journal.asset.JournalArticleAssetRendererFactory;
199 import com.liferay.portlet.journal.model.JournalArticle;
200 import com.liferay.portlet.journal.model.JournalArticleConstants;
201 import com.liferay.portlet.journal.model.JournalFolder;
202 import com.liferay.portlet.journal.service.JournalArticleLocalServiceUtil;
203 import com.liferay.portlet.login.util.LoginUtil;
204 import com.liferay.portlet.messageboards.action.EditDiscussionAction;
205 import com.liferay.portlet.messageboards.model.MBMessage;
206 import com.liferay.portlet.messageboards.model.MBThread;
207 import com.liferay.portlet.sites.util.Sites;
208 import com.liferay.portlet.sites.util.SitesUtil;
209 import com.liferay.portlet.social.model.SocialRelationConstants;
210 import com.liferay.portlet.social.util.FacebookUtil;
211 import com.liferay.portlet.wiki.model.WikiPage;
212 import com.liferay.util.Encryptor;
213 import com.liferay.util.JS;
214
215 import java.io.IOException;
216 import java.io.Serializable;
217
218 import java.lang.reflect.Method;
219
220 import java.net.InetAddress;
221 import java.net.UnknownHostException;
222
223 import java.util.ArrayList;
224 import java.util.Arrays;
225 import java.util.Calendar;
226 import java.util.Collection;
227 import java.util.Date;
228 import java.util.Enumeration;
229 import java.util.HashMap;
230 import java.util.HashSet;
231 import java.util.Iterator;
232 import java.util.LinkedHashMap;
233 import java.util.List;
234 import java.util.Locale;
235 import java.util.Map;
236 import java.util.Properties;
237 import java.util.ResourceBundle;
238 import java.util.Set;
239 import java.util.TimeZone;
240 import java.util.TreeSet;
241 import java.util.concurrent.ConcurrentHashMap;
242 import java.util.concurrent.atomic.AtomicInteger;
243 import java.util.regex.Matcher;
244 import java.util.regex.Pattern;
245
246 import javax.portlet.ActionRequest;
247 import javax.portlet.ActionResponse;
248 import javax.portlet.PortletConfig;
249 import javax.portlet.PortletException;
250 import javax.portlet.PortletMode;
251 import javax.portlet.PortletPreferences;
252 import javax.portlet.PortletRequest;
253 import javax.portlet.PortletResponse;
254 import javax.portlet.PortletURL;
255 import javax.portlet.PreferencesValidator;
256 import javax.portlet.RenderRequest;
257 import javax.portlet.RenderResponse;
258 import javax.portlet.ValidatorException;
259 import javax.portlet.WindowState;
260
261 import javax.servlet.RequestDispatcher;
262 import javax.servlet.ServletContext;
263 import javax.servlet.ServletException;
264 import javax.servlet.http.Cookie;
265 import javax.servlet.http.HttpServletRequest;
266 import javax.servlet.http.HttpServletRequestWrapper;
267 import javax.servlet.http.HttpServletResponse;
268 import javax.servlet.http.HttpSession;
269 import javax.servlet.jsp.PageContext;
270
271 import org.apache.struts.Globals;
272
273
283 @DoPrivileged
284 public class PortalImpl implements Portal {
285
286 public PortalImpl() {
287
288
289
290 _computerName = System.getProperty("env.COMPUTERNAME");
291
292 if (Validator.isNull(_computerName)) {
293 _computerName = System.getProperty("env.HOST");
294 }
295
296 if (Validator.isNull(_computerName)) {
297 _computerName = System.getProperty("env.HOSTNAME");
298 }
299
300 if (Validator.isNull(_computerName)) {
301 try {
302 InetAddress inetAddress = InetAddress.getLocalHost();
303
304 _computerName = inetAddress.getHostName();
305 }
306 catch (UnknownHostException uhe) {
307 }
308 }
309
310 try {
311 InetAddress inetAddress = InetAddress.getByName(_computerName);
312
313 _computerAddress = inetAddress.getHostAddress();
314 }
315 catch (UnknownHostException uhe) {
316 }
317
318 if (Validator.isNull(_computerAddress)) {
319 try {
320 InetAddress inetAddress = InetAddress.getLocalHost();
321
322 _computerAddress = inetAddress.getHostAddress();
323 }
324 catch (UnknownHostException uhe) {
325 }
326 }
327
328
329
330 _pathProxy = PropsValues.PORTAL_PROXY_PATH;
331
332 _pathContext = ContextPathUtil.getContextPath(
333 PortalContextLoaderListener.getPortalServletContextPath());
334 _pathContext = _pathProxy.concat(_pathContext);
335
336 _pathFriendlyURLPrivateGroup =
337 _pathContext + _PRIVATE_GROUP_SERVLET_MAPPING;
338 _pathFriendlyURLPrivateUser =
339 _pathContext + _PRIVATE_USER_SERVLET_MAPPING;
340 _pathFriendlyURLPublic = _pathContext + _PUBLIC_GROUP_SERVLET_MAPPING;
341 _pathImage = _pathContext + PATH_IMAGE;
342 _pathMain = _pathContext + PATH_MAIN;
343 _pathModule = _pathContext + PATH_MODULE;
344
345
346
347 String[] customSystemGroups = PropsUtil.getArray(
348 PropsKeys.SYSTEM_GROUPS);
349
350 if (ArrayUtil.isEmpty(customSystemGroups)) {
351 _allSystemGroups = GroupConstants.SYSTEM_GROUPS;
352 }
353 else {
354 _allSystemGroups = ArrayUtil.append(
355 GroupConstants.SYSTEM_GROUPS, customSystemGroups);
356 }
357
358 _sortedSystemGroups = new String[_allSystemGroups.length];
359
360 System.arraycopy(
361 _allSystemGroups, 0, _sortedSystemGroups, 0,
362 _allSystemGroups.length);
363
364 Arrays.sort(_sortedSystemGroups, new StringComparator());
365
366
367
368 String[] customSystemRoles = PropsUtil.getArray(PropsKeys.SYSTEM_ROLES);
369
370 if (ArrayUtil.isEmpty(customSystemRoles)) {
371 _allSystemRoles = RoleConstants.SYSTEM_ROLES;
372 }
373 else {
374 _allSystemRoles = ArrayUtil.append(
375 RoleConstants.SYSTEM_ROLES, customSystemRoles);
376 }
377
378 _sortedSystemRoles = new String[_allSystemRoles.length];
379
380 System.arraycopy(
381 _allSystemRoles, 0, _sortedSystemRoles, 0, _allSystemRoles.length);
382
383 Arrays.sort(_sortedSystemRoles, new StringComparator());
384
385
386
387 String[] customSystemOrganizationRoles = PropsUtil.getArray(
388 PropsKeys.SYSTEM_ORGANIZATION_ROLES);
389
390 if (ArrayUtil.isEmpty(customSystemOrganizationRoles)) {
391 _allSystemOrganizationRoles =
392 RoleConstants.SYSTEM_ORGANIZATION_ROLES;
393 }
394 else {
395 _allSystemOrganizationRoles = ArrayUtil.append(
396 RoleConstants.SYSTEM_ORGANIZATION_ROLES,
397 customSystemOrganizationRoles);
398 }
399
400 _sortedSystemOrganizationRoles =
401 new String[_allSystemOrganizationRoles.length];
402
403 System.arraycopy(
404 _allSystemOrganizationRoles, 0, _sortedSystemOrganizationRoles, 0,
405 _allSystemOrganizationRoles.length);
406
407 Arrays.sort(_sortedSystemOrganizationRoles, new StringComparator());
408
409
410
411 String[] customSystemSiteRoles = PropsUtil.getArray(
412 PropsKeys.SYSTEM_SITE_ROLES);
413
414 if (ArrayUtil.isEmpty(customSystemSiteRoles)) {
415 _allSystemSiteRoles = RoleConstants.SYSTEM_SITE_ROLES;
416 }
417 else {
418 _allSystemSiteRoles = ArrayUtil.append(
419 RoleConstants.SYSTEM_SITE_ROLES, customSystemSiteRoles);
420 }
421
422 _sortedSystemSiteRoles = new String[_allSystemSiteRoles.length];
423
424 System.arraycopy(
425 _allSystemSiteRoles, 0, _sortedSystemSiteRoles, 0,
426 _allSystemSiteRoles.length);
427
428 Arrays.sort(_sortedSystemSiteRoles, new StringComparator());
429
430
431
432 _reservedParams = new HashSet<String>();
433
434
435
436 _reservedParams.add("p_auth");
437 _reservedParams.add("p_auth_secret");
438
439
440
441 _reservedParams.add("p_l_id");
442 _reservedParams.add("p_l_reset");
443
444
445
446 _reservedParams.add("p_p_auth");
447 _reservedParams.add("p_p_id");
448 _reservedParams.add("p_p_i_id");
449 _reservedParams.add("p_p_lifecycle");
450 _reservedParams.add("p_p_url_type");
451 _reservedParams.add("p_p_state");
452 _reservedParams.add("p_p_state_rcv");
453 _reservedParams.add("p_p_mode");
454 _reservedParams.add("p_p_resource_id");
455 _reservedParams.add("p_p_cacheability");
456 _reservedParams.add("p_p_width");
457 _reservedParams.add("p_p_col_id");
458 _reservedParams.add("p_p_col_pos");
459 _reservedParams.add("p_p_col_count");
460 _reservedParams.add("p_p_static");
461 _reservedParams.add("p_p_isolated");
462
463
464
465 _reservedParams.add("p_t_lifecycle");
466
467
468
469 _reservedParams.add("p_v_l_s_g_id");
470
471
472
473 _reservedParams.add("p_f_id");
474
475
476
477 _reservedParams.add("p_j_a_id");
478
479
480
481 _reservedParams.add("saveLastPath");
482 _reservedParams.add("scroll");
483 _reservedParams.add("switchGroup");
484
485 _servletContextName =
486 PortalContextLoaderListener.getPortalServlerContextName();
487
488 if (ArrayUtil.isEmpty(PropsValues.VIRTUAL_HOSTS_VALID_HOSTS) ||
489 ArrayUtil.contains(
490 PropsValues.VIRTUAL_HOSTS_VALID_HOSTS, StringPool.STAR)) {
491
492 _validPortalDomainCheckDisabled = true;
493 }
494 }
495
496 @Override
497 public void addPageDescription(
498 String description, HttpServletRequest request) {
499
500 ListMergeable<String> descriptionListMergeable =
501 (ListMergeable<String>)request.getAttribute(
502 WebKeys.PAGE_DESCRIPTION);
503
504 if (descriptionListMergeable == null) {
505 descriptionListMergeable = new ListMergeable<String>();
506
507 request.setAttribute(
508 WebKeys.PAGE_DESCRIPTION, descriptionListMergeable);
509 }
510
511 descriptionListMergeable.add(description);
512 }
513
514 @Override
515 public void addPageKeywords(String keywords, HttpServletRequest request) {
516 ListMergeable<String> keywordsListMergeable =
517 (ListMergeable<String>)request.getAttribute(WebKeys.PAGE_KEYWORDS);
518
519 if (keywordsListMergeable == null) {
520 keywordsListMergeable = new ListMergeable<String>();
521
522 request.setAttribute(WebKeys.PAGE_KEYWORDS, keywordsListMergeable);
523 }
524
525 String[] keywordsArray = StringUtil.split(keywords);
526
527 for (String keyword : keywordsArray) {
528 if (!keywordsListMergeable.contains(
529 StringUtil.toLowerCase(keyword))) {
530
531 keywordsListMergeable.add(StringUtil.toLowerCase(keyword));
532 }
533 }
534 }
535
536 @Override
537 public void addPageSubtitle(String subtitle, HttpServletRequest request) {
538 ListMergeable<String> subtitleListMergeable =
539 (ListMergeable<String>)request.getAttribute(WebKeys.PAGE_SUBTITLE);
540
541 if (subtitleListMergeable == null) {
542 subtitleListMergeable = new ListMergeable<String>();
543
544 request.setAttribute(WebKeys.PAGE_SUBTITLE, subtitleListMergeable);
545 }
546
547 subtitleListMergeable.add(subtitle);
548 }
549
550 @Override
551 public void addPageTitle(String title, HttpServletRequest request) {
552 ListMergeable<String> titleListMergeable =
553 (ListMergeable<String>)request.getAttribute(WebKeys.PAGE_TITLE);
554
555 if (titleListMergeable == null) {
556 titleListMergeable = new ListMergeable<String>();
557
558 request.setAttribute(WebKeys.PAGE_TITLE, titleListMergeable);
559 }
560
561 titleListMergeable.add(title);
562 }
563
564 @Override
565 public void addPortalPortEventListener(
566 PortalPortEventListener portalPortEventListener) {
567
568 if (!_portalPortEventListeners.contains(portalPortEventListener)) {
569 _portalPortEventListeners.add(portalPortEventListener);
570 }
571 }
572
573 @Override
574 public void addPortalPortProtocolEventListener(
575 PortalPortProtocolEventListener portalPortProtocolEventListener) {
576
577 if (!_portalPortProtocolEventListeners.contains(
578 portalPortProtocolEventListener)) {
579
580 _portalPortProtocolEventListeners.add(
581 portalPortProtocolEventListener);
582 }
583 }
584
585 @Override
586 public void addPortletBreadcrumbEntry(
587 HttpServletRequest request, String title, String url) {
588
589 addPortletBreadcrumbEntry(request, title, url, null);
590 }
591
592 @Override
593 public void addPortletBreadcrumbEntry(
594 HttpServletRequest request, String title, String url,
595 Map<String, Object> data) {
596
597 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
598 WebKeys.THEME_DISPLAY);
599
600 PortletDisplay portletDisplay = themeDisplay.getPortletDisplay();
601
602 String name = WebKeys.PORTLET_BREADCRUMBS;
603
604 if (Validator.isNotNull(portletDisplay.getId()) &&
605 !portletDisplay.isFocused()) {
606
607 name += StringPool.UNDERLINE + portletDisplay.getId();
608 }
609
610 List<BreadcrumbEntry> breadcrumbEntries =
611 (List<BreadcrumbEntry>)request.getAttribute(name);
612
613 if (breadcrumbEntries == null) {
614 breadcrumbEntries = new ArrayList<BreadcrumbEntry>();
615
616 request.setAttribute(name, breadcrumbEntries);
617 }
618
619 BreadcrumbEntry breadcrumbEntry = new BreadcrumbEntry();
620
621 breadcrumbEntry.setData(data);
622 breadcrumbEntry.setTitle(title);
623 breadcrumbEntry.setURL(url);
624
625 breadcrumbEntries.add(breadcrumbEntry);
626 }
627
628 @Override
629 public void addPortletDefaultResource(
630 HttpServletRequest request, Portlet portlet)
631 throws PortalException, SystemException {
632
633 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
634 WebKeys.THEME_DISPLAY);
635
636 Layout layout = themeDisplay.getLayout();
637
638 long groupId = 0;
639
640 if (layout.isTypeControlPanel()) {
641 groupId = themeDisplay.getScopeGroupId();
642 }
643 else {
644 groupId = getScopeGroupId(layout, portlet.getPortletId());
645 }
646
647 addDefaultResource(
648 themeDisplay.getCompanyId(), groupId, layout, portlet, true);
649 addDefaultResource(
650 themeDisplay.getCompanyId(), groupId, layout, portlet, false);
651 }
652
653 @Override
654 public void addPortletDefaultResource(
655 long companyId, Layout layout, Portlet portlet)
656 throws PortalException, SystemException {
657
658 addDefaultResource(companyId, layout, portlet, true);
659 addDefaultResource(companyId, layout, portlet, false);
660 }
661
662 @Override
663 public String addPreservedParameters(
664 ThemeDisplay themeDisplay, Layout layout, String url,
665 boolean doAsUser) {
666
667 if (doAsUser) {
668 if (Validator.isNotNull(themeDisplay.getDoAsUserId())) {
669 url = HttpUtil.setParameter(
670 url, "doAsUserId", themeDisplay.getDoAsUserId());
671 }
672
673 if (Validator.isNotNull(themeDisplay.getDoAsUserLanguageId())) {
674 url = HttpUtil.setParameter(
675 url, "doAsUserLanguageId",
676 themeDisplay.getDoAsUserLanguageId());
677 }
678 }
679
680 if (layout.isTypeControlPanel()) {
681 if (themeDisplay.getDoAsGroupId() > 0) {
682 url = HttpUtil.setParameter(
683 url, "doAsGroupId", themeDisplay.getDoAsGroupId());
684 }
685
686 if (themeDisplay.getRefererPlid() != LayoutConstants.DEFAULT_PLID) {
687 url = HttpUtil.setParameter(
688 url, "refererPlid", themeDisplay.getRefererPlid());
689 }
690
691 if (Validator.isNotNull(themeDisplay.getControlPanelCategory())) {
692 url = HttpUtil.setParameter(
693 url, "controlPanelCategory",
694 themeDisplay.getControlPanelCategory());
695 }
696 }
697
698 return url;
699 }
700
701 @Override
702 public String addPreservedParameters(
703 ThemeDisplay themeDisplay, String url) {
704
705 return addPreservedParameters(
706 themeDisplay, themeDisplay.getLayout(), url, true);
707 }
708
709 @Override
710 public void addUserLocaleOptionsMessage(HttpServletRequest request) {
711 boolean ignoreUserLocaleOptions = GetterUtil.getBoolean(
712 SessionClicks.get(
713 request.getSession(), "ignoreUserLocaleOptions",
714 Boolean.FALSE.toString()));
715
716 if (ignoreUserLocaleOptions) {
717 return;
718 }
719
720 boolean showUserLocaleOptionsMessage = ParamUtil.getBoolean(
721 request, "showUserLocaleOptionsMessage", true);
722
723 if (!showUserLocaleOptionsMessage) {
724 return;
725 }
726
727 PortalMessages.add(request, PortalMessages.KEY_ANIMATION, false);
728 PortalMessages.add(
729 request, PortalMessages.KEY_JSP_PATH,
730 "/html/common/themes/user_locale_options.jsp");
731 PortalMessages.add(request, PortalMessages.KEY_TIMEOUT, -1);
732 }
733
734 @Override
735 public void clearRequestParameters(RenderRequest renderRequest) {
736 RenderRequestImpl renderRequestImpl = (RenderRequestImpl)renderRequest;
737
738 if (renderRequestImpl.isTriggeredByActionURL()) {
739 Map<String, String[]> renderParameters =
740 renderRequestImpl.getRenderParameters();
741
742 renderParameters.clear();
743 }
744 }
745
746 @Override
747 public void copyRequestParameters(
748 ActionRequest actionRequest, ActionResponse actionResponse) {
749
750 if (actionResponse instanceof StateAwareResponseImpl) {
751 StateAwareResponseImpl stateAwareResponseImpl =
752 (StateAwareResponseImpl)actionResponse;
753
754 if (stateAwareResponseImpl.getRedirectLocation() != null) {
755 if (_log.isDebugEnabled()) {
756 _log.debug(
757 "Cannot copy parameters on a redirected " +
758 "StateAwareResponseImpl");
759 }
760
761 return;
762 }
763 }
764
765 ActionResponseImpl actionResponseImpl =
766 (ActionResponseImpl)actionResponse;
767
768 Map<String, String[]> renderParameters =
769 actionResponseImpl.getRenderParameterMap();
770
771 actionResponse.setRenderParameter("p_p_lifecycle", "1");
772
773 Enumeration<String> enu = actionRequest.getParameterNames();
774
775 while (enu.hasMoreElements()) {
776 String param = enu.nextElement();
777 String[] values = actionRequest.getParameterValues(param);
778
779 if (renderParameters.get(
780 actionResponseImpl.getNamespace() + param) == null) {
781
782 actionResponse.setRenderParameter(param, values);
783 }
784 }
785 }
786
787 @Override
788 public String escapeRedirect(String url) {
789 if (Validator.isNull(url) || !HttpUtil.hasDomain(url)) {
790 return url;
791 }
792
793 String domain = HttpUtil.getDomain(url);
794
795 int pos = domain.indexOf(CharPool.COLON);
796
797 if (pos != -1) {
798 domain = domain.substring(0, pos);
799 }
800
801 if (!_validPortalDomainCheckDisabled && isValidPortalDomain(domain)) {
802 return url;
803 }
804
805 try {
806 String securityMode = PropsValues.REDIRECT_URL_SECURITY_MODE;
807
808 if (securityMode.equals("domain")) {
809 String[] allowedDomains =
810 PropsValues.REDIRECT_URL_DOMAINS_ALLOWED;
811
812 if ((allowedDomains.length > 0) &&
813 !ArrayUtil.contains(allowedDomains, domain)) {
814
815 if (_log.isDebugEnabled()) {
816 _log.debug("Redirect URL " + url + " is not allowed");
817 }
818
819 url = null;
820 }
821 }
822 else if (securityMode.equals("ip")) {
823 String[] allowedIps = PropsValues.REDIRECT_URL_IPS_ALLOWED;
824
825 if (allowedIps.length == 0) {
826 return url;
827 }
828
829 InetAddress inetAddress = InetAddress.getByName(domain);
830
831 String hostAddress = inetAddress.getHostAddress();
832
833 String serverIp = getComputerAddress();
834
835 boolean serverIpIsHostAddress = serverIp.equals(hostAddress);
836
837 for (String ip : allowedIps) {
838 if ((serverIpIsHostAddress && ip.equals("SERVER_IP")) ||
839 ip.equals(hostAddress)) {
840
841 return url;
842 }
843 }
844
845 if (_log.isDebugEnabled()) {
846 _log.debug("Redirect URL " + url + " is not allowed");
847 }
848
849 url = null;
850 }
851 }
852 catch (UnknownHostException uhe) {
853 if (_log.isDebugEnabled()) {
854 _log.debug("Unable to determine IP for redirect URL " + url);
855 }
856
857 url = null;
858 }
859
860 return url;
861 }
862
863 @Override
864 public String generateRandomKey(HttpServletRequest request, String input) {
865 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
866 WebKeys.THEME_DISPLAY);
867
868 if (themeDisplay.isAjax() || themeDisplay.isIsolated() ||
869 themeDisplay.isLifecycleResource() ||
870 themeDisplay.isStateExclusive()) {
871
872 return StringUtil.randomId();
873 }
874 else {
875 StringBundler sb = new StringBundler(5);
876
877 sb.append(DeterminateKeyGenerator.generate(input));
878 sb.append(StringPool.UNDERLINE);
879 sb.append(request.getAttribute(WebKeys.RENDER_PORTLET_COLUMN_ID));
880 sb.append(StringPool.UNDERLINE);
881 sb.append(request.getAttribute(WebKeys.RENDER_PORTLET_COLUMN_POS));
882
883 return JS.getSafeName(sb.toString());
884 }
885 }
886
887 @Override
888 public String getAbsoluteURL(HttpServletRequest request, String url) {
889 String portalURL = getPortalURL(request);
890
891 if (url.charAt(0) == CharPool.SLASH) {
892 if (Validator.isNotNull(portalURL)) {
893 url = portalURL.concat(url);
894 }
895 }
896
897 if (!CookieKeys.hasSessionId(request) && url.startsWith(portalURL)) {
898 url = getURLWithSessionId(url, request.getSession().getId());
899 }
900
901 return url;
902 }
903
904 @Override
905 public LayoutQueryStringComposite getActualLayoutQueryStringComposite(
906 long groupId, boolean privateLayout, String friendlyURL,
907 Map<String, String[]> params, Map<String, Object> requestContext)
908 throws PortalException, SystemException {
909
910 Layout layout = null;
911 String layoutQueryStringCompositeFriendlyURL = friendlyURL;
912 String queryString = StringPool.BLANK;
913
914 if (Validator.isNull(friendlyURL)) {
915
916
917
918 List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
919 groupId, privateLayout,
920 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID);
921
922 if (!layouts.isEmpty()) {
923 layout = layouts.get(0);
924 }
925 else {
926 throw new NoSuchLayoutException(
927 "{groupId=" + groupId + ", privateLayout=" + privateLayout +
928 "}");
929 }
930 }
931 else {
932 LayoutQueryStringComposite layoutQueryStringComposite =
933 getPortletFriendlyURLMapperLayoutQueryStringComposite(
934 groupId, privateLayout, friendlyURL, params,
935 requestContext);
936
937 layout = layoutQueryStringComposite.getLayout();
938 layoutQueryStringCompositeFriendlyURL =
939 layoutQueryStringComposite.getFriendlyURL();
940 queryString = layoutQueryStringComposite.getQueryString();
941 }
942
943 return new LayoutQueryStringComposite(
944 layout, layoutQueryStringCompositeFriendlyURL, queryString);
945 }
946
947 @Override
948 public String getActualURL(
949 long groupId, boolean privateLayout, String mainPath,
950 String friendlyURL, Map<String, String[]> params,
951 Map<String, Object> requestContext)
952 throws PortalException, SystemException {
953
954 String actualURL = null;
955
956 if (friendlyURL != null) {
957 if (friendlyURL.startsWith(
958 JournalArticleConstants.CANONICAL_URL_SEPARATOR)) {
959
960 try {
961 actualURL = getJournalArticleActualURL(
962 groupId, privateLayout, mainPath, friendlyURL, params,
963 requestContext);
964 }
965 catch (Exception e) {
966 throw new NoSuchLayoutException(e);
967 }
968 }
969 else if (friendlyURL.startsWith(
970 VirtualLayoutConstants.CANONICAL_URL_SEPARATOR)) {
971
972 try {
973 actualURL = getVirtualLayoutActualURL(
974 groupId, privateLayout, mainPath, friendlyURL, params,
975 requestContext);
976 }
977 catch (Exception e) {
978 throw new NoSuchLayoutException(e);
979 }
980 }
981 }
982
983 if (actualURL == null) {
984 actualURL = getLayoutActualURL(
985 groupId, privateLayout, mainPath, friendlyURL, params,
986 requestContext);
987 }
988
989 return actualURL;
990 }
991
992
996 @Override
997 public Locale[] getAlternateLocales(HttpServletRequest request) {
998 return LanguageUtil.getAvailableLocales();
999 }
1000
1001 @Override
1002 public String getAlternateURL(
1003 String canonicalURL, ThemeDisplay themeDisplay, Locale locale,
1004 Layout layout)
1005 throws PortalException, SystemException {
1006
1007 String virtualHostname = getVirtualHostname(
1008 themeDisplay.getLayoutSet());
1009
1010 if (Validator.isNull(virtualHostname)) {
1011 Company company = themeDisplay.getCompany();
1012
1013 virtualHostname = company.getVirtualHostname();
1014 }
1015
1016 String portalURL = themeDisplay.getPortalURL();
1017
1018 String portalDomain = HttpUtil.getDomain(portalURL);
1019
1020 if (!Validator.isBlank(portalDomain) &&
1021 !StringUtil.equalsIgnoreCase(portalDomain, _LOCALHOST) &&
1022 StringUtil.equalsIgnoreCase(virtualHostname, _LOCALHOST)) {
1023
1024 virtualHostname = portalDomain;
1025 }
1026
1027 String i18nPath = buildI18NPath(locale);
1028
1029 if (Validator.isNull(virtualHostname)) {
1030 return canonicalURL.replaceFirst(
1031 _PUBLIC_GROUP_SERVLET_MAPPING,
1032 i18nPath.concat(_PUBLIC_GROUP_SERVLET_MAPPING));
1033 }
1034
1035
1036
1037 int pos = canonicalURL.indexOf(virtualHostname);
1038
1039 if (pos > 0) {
1040 pos = canonicalURL.indexOf(
1041 CharPool.SLASH, pos + virtualHostname.length());
1042
1043 if (Validator.isNotNull(_pathContext)) {
1044 pos = canonicalURL.indexOf(
1045 CharPool.SLASH, pos + _pathContext.length());
1046 }
1047
1048 if ((pos > 0) && (pos < canonicalURL.length())) {
1049 boolean replaceFriendlyURL = true;
1050
1051 String currentURL = canonicalURL.substring(pos);
1052
1053 int[] friendlyURLIndex = getGroupFriendlyURLIndex(currentURL);
1054
1055 if (friendlyURLIndex != null) {
1056 int y = friendlyURLIndex[1];
1057
1058 currentURL = currentURL.substring(y);
1059
1060 if (currentURL.equals(StringPool.SLASH)) {
1061 replaceFriendlyURL = false;
1062 }
1063 }
1064
1065 if (replaceFriendlyURL) {
1066 String canonicalURLPrefix = canonicalURL.substring(0, pos);
1067
1068 String canonicalURLSuffix = canonicalURL.substring(pos);
1069
1070 canonicalURLSuffix = StringUtil.replaceFirst(
1071 canonicalURLSuffix, layout.getFriendlyURL(),
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(false);
3227
3228 if ((session != null) &&
3229 session.getAttribute(Globals.LOCALE_KEY) != null) {
3230
3231 locale = (Locale)session.getAttribute(Globals.LOCALE_KEY);
3232
3233 if (LanguageUtil.isAvailableLocale(groupId, locale)) {
3234 return locale;
3235 }
3236 }
3237
3238
3239
3240 if (user == null) {
3241 try {
3242 user = getUser(request);
3243 }
3244 catch (Exception e) {
3245 }
3246 }
3247
3248 if ((user != null) && !user.isDefaultUser()) {
3249 Locale userLocale = getAvailableLocale(groupId, user.getLocale());
3250
3251 if (userLocale != null) {
3252 if (LanguageUtil.isAvailableLocale(groupId, userLocale)) {
3253 if (initialize) {
3254 setLocale(request, response, userLocale);
3255 }
3256
3257 return userLocale;
3258 }
3259 }
3260 }
3261
3262
3263
3264 String languageId = CookieKeys.getCookie(
3265 request, CookieKeys.GUEST_LANGUAGE_ID, false);
3266
3267 if (Validator.isNotNull(languageId)) {
3268 Locale cookieLocale = getAvailableLocale(
3269 groupId, LocaleUtil.fromLanguageId(languageId));
3270
3271 if (cookieLocale != null) {
3272 if (LanguageUtil.isAvailableLocale(groupId, cookieLocale)) {
3273 if (initialize) {
3274 setLocale(request, response, cookieLocale);
3275 }
3276
3277 return cookieLocale;
3278 }
3279 }
3280 }
3281
3282
3283
3284 if (PropsValues.LOCALE_DEFAULT_REQUEST) {
3285 Enumeration<Locale> locales = request.getLocales();
3286
3287 while (locales.hasMoreElements()) {
3288 Locale requestLocale = getAvailableLocale(
3289 groupId, locales.nextElement());
3290
3291 if (requestLocale != null) {
3292 if (LanguageUtil.isAvailableLocale(
3293 groupId, requestLocale)) {
3294
3295 if (initialize) {
3296 setLocale(request, response, requestLocale);
3297 }
3298
3299 return requestLocale;
3300 }
3301 }
3302 }
3303 }
3304
3305
3306
3307 Company company = null;
3308
3309 try {
3310 company = getCompany(request);
3311 }
3312 catch (Exception e) {
3313 }
3314
3315 if (company == null) {
3316 return null;
3317 }
3318
3319 User defaultUser = null;
3320
3321 try {
3322 defaultUser = company.getDefaultUser();
3323 }
3324 catch (Exception e) {
3325 }
3326
3327 if (defaultUser == null) {
3328 return null;
3329 }
3330
3331 Locale defaultUserLocale = getAvailableLocale(
3332 groupId, defaultUser.getLocale());
3333
3334 if (defaultUserLocale != null) {
3335 if (LanguageUtil.isAvailableLocale(groupId, defaultUserLocale)) {
3336 if (initialize) {
3337 setLocale(request, response, defaultUserLocale);
3338 }
3339
3340 return defaultUserLocale;
3341 }
3342 }
3343
3344 try {
3345 if (themeDisplay != null) {
3346 return themeDisplay.getSiteDefaultLocale();
3347 }
3348 }
3349 catch (Exception e) {
3350 }
3351
3352 try {
3353 return getSiteDefaultLocale(groupId);
3354 }
3355 catch (Exception e) {
3356 return LocaleUtil.getDefault();
3357 }
3358 }
3359
3360 @Override
3361 public Locale getLocale(PortletRequest portletRequest) {
3362 return getLocale(getHttpServletRequest(portletRequest));
3363 }
3364
3365 @Override
3366 public String getLocalizedFriendlyURL(
3367 HttpServletRequest request, Layout layout, Locale locale,
3368 Locale originalLocale)
3369 throws Exception {
3370
3371 String contextPath = getPathContext();
3372
3373 String requestURI = request.getRequestURI();
3374
3375 if (Validator.isNotNull(contextPath) &&
3376 requestURI.contains(contextPath)) {
3377
3378 requestURI = requestURI.substring(contextPath.length());
3379 }
3380
3381 requestURI = StringUtil.replace(
3382 requestURI, StringPool.DOUBLE_SLASH, StringPool.SLASH);
3383
3384 String path = request.getPathInfo();
3385
3386 int x = path.indexOf(CharPool.SLASH, 1);
3387
3388 String layoutFriendlyURL = null;
3389
3390 if (originalLocale == null) {
3391 if ((x != -1) && ((x + 1) != path.length())) {
3392 layoutFriendlyURL = path.substring(x);
3393 }
3394
3395 int y = layoutFriendlyURL.indexOf(
3396 VirtualLayoutConstants.CANONICAL_URL_SEPARATOR);
3397
3398 if (y != -1) {
3399 y = layoutFriendlyURL.indexOf(CharPool.SLASH, 3);
3400
3401 if ((y != -1) && ((y + 1) != layoutFriendlyURL.length())) {
3402 layoutFriendlyURL = layoutFriendlyURL.substring(y);
3403 }
3404 }
3405
3406 y = layoutFriendlyURL.indexOf(Portal.FRIENDLY_URL_SEPARATOR);
3407
3408 if (y != -1) {
3409 layoutFriendlyURL = layoutFriendlyURL.substring(0, y);
3410 }
3411 }
3412 else {
3413 layoutFriendlyURL = layout.getFriendlyURL(originalLocale);
3414 }
3415
3416 if (requestURI.contains(layoutFriendlyURL)) {
3417 requestURI = StringUtil.replaceFirst(
3418 requestURI, layoutFriendlyURL, layout.getFriendlyURL(locale));
3419 }
3420
3421 String i18nPath = getI18nPathLanguageId(
3422 locale, LocaleUtil.toLanguageId(locale));
3423
3424 String localizedFriendlyURL =
3425 contextPath + StringPool.SLASH + i18nPath + requestURI;
3426
3427 String queryString = request.getQueryString();
3428
3429 if (Validator.isNotNull(queryString)) {
3430 localizedFriendlyURL +=
3431 StringPool.QUESTION + request.getQueryString();
3432 }
3433
3434 return localizedFriendlyURL;
3435 }
3436
3437 @Override
3438 public String getMailId(String mx, String popPortletPrefix, Object... ids) {
3439 StringBundler sb = new StringBundler(ids.length * 2 + 7);
3440
3441 sb.append(StringPool.LESS_THAN);
3442 sb.append(popPortletPrefix);
3443
3444 if (!popPortletPrefix.endsWith(StringPool.PERIOD)) {
3445 sb.append(StringPool.PERIOD);
3446 }
3447
3448 for (int i = 0; i < ids.length; i++) {
3449 Object id = ids[i];
3450
3451 if (i != 0) {
3452 sb.append(StringPool.PERIOD);
3453 }
3454
3455 sb.append(id);
3456 }
3457
3458 sb.append(StringPool.AT);
3459
3460 if (Validator.isNotNull(PropsValues.POP_SERVER_SUBDOMAIN)) {
3461 sb.append(PropsValues.POP_SERVER_SUBDOMAIN);
3462 sb.append(StringPool.PERIOD);
3463 }
3464
3465 sb.append(mx);
3466 sb.append(StringPool.GREATER_THAN);
3467
3468 return sb.toString();
3469 }
3470
3471 @Override
3472 public String getNetvibesURL(Portlet portlet, ThemeDisplay themeDisplay)
3473 throws PortalException, SystemException {
3474
3475 return getServletURL(
3476 portlet, PropsValues.NETVIBES_SERVLET_MAPPING, themeDisplay);
3477 }
3478
3479 @Override
3480 public String getNewPortletTitle(
3481 String portletTitle, String oldScopeName, String newScopeName) {
3482
3483 if (portletTitle.endsWith(" (" + oldScopeName + ")")) {
3484 int pos = portletTitle.lastIndexOf(" (" + oldScopeName + ")");
3485
3486 portletTitle = portletTitle.substring(0, pos);
3487 }
3488
3489 if (Validator.isNull(newScopeName)) {
3490 return portletTitle;
3491 }
3492
3493 StringBundler sb = new StringBundler(5);
3494
3495 sb.append(portletTitle);
3496 sb.append(StringPool.SPACE);
3497 sb.append(StringPool.OPEN_PARENTHESIS);
3498 sb.append(newScopeName);
3499 sb.append(StringPool.CLOSE_PARENTHESIS);
3500
3501 return sb.toString();
3502 }
3503
3504 @Override
3505 public HttpServletRequest getOriginalServletRequest(
3506 HttpServletRequest request) {
3507
3508 List<PersistentHttpServletRequestWrapper>
3509 persistentHttpServletRequestWrappers =
3510 new ArrayList<PersistentHttpServletRequestWrapper>();
3511
3512 HttpServletRequest originalRequest = request;
3513
3514 while (originalRequest.getClass().getName().startsWith(
3515 "com.liferay.")) {
3516
3517 if (originalRequest instanceof
3518 PersistentHttpServletRequestWrapper) {
3519
3520 PersistentHttpServletRequestWrapper
3521 persistentHttpServletRequestWrapper =
3522 (PersistentHttpServletRequestWrapper)originalRequest;
3523
3524 persistentHttpServletRequestWrappers.add(
3525 persistentHttpServletRequestWrapper.clone());
3526 }
3527
3528
3529
3530
3531 HttpServletRequestWrapper httpServletRequestWrapper =
3532 (HttpServletRequestWrapper)originalRequest;
3533
3534 originalRequest =
3535 (HttpServletRequest)httpServletRequestWrapper.getRequest();
3536 }
3537
3538 for (int i = persistentHttpServletRequestWrappers.size() - 1; i >= 0;
3539 i--) {
3540
3541 HttpServletRequestWrapper httpServletRequestWrapper =
3542 persistentHttpServletRequestWrappers.get(i);
3543
3544 httpServletRequestWrapper.setRequest(originalRequest);
3545
3546 originalRequest = httpServletRequestWrapper;
3547 }
3548
3549 return originalRequest;
3550 }
3551
3552
3555 @Override
3556 public long getParentGroupId(long groupId)
3557 throws PortalException, SystemException {
3558
3559 return getSiteGroupId(groupId);
3560 }
3561
3562 @Override
3563 public String getPathContext() {
3564 return _pathContext;
3565 }
3566
3567 @Override
3568 public String getPathContext(HttpServletRequest request) {
3569 return getPathContext(request.getContextPath());
3570 }
3571
3572 @Override
3573 public String getPathContext(PortletRequest portletRequest) {
3574 return getPathContext(portletRequest.getContextPath());
3575 }
3576
3577 @Override
3578 public String getPathContext(String contextPath) {
3579 return _pathProxy.concat(ContextPathUtil.getContextPath(contextPath));
3580 }
3581
3582 @Override
3583 public String getPathFriendlyURLPrivateGroup() {
3584 return _pathFriendlyURLPrivateGroup;
3585 }
3586
3587 @Override
3588 public String getPathFriendlyURLPrivateUser() {
3589 return _pathFriendlyURLPrivateUser;
3590 }
3591
3592 @Override
3593 public String getPathFriendlyURLPublic() {
3594 return _pathFriendlyURLPublic;
3595 }
3596
3597 @Override
3598 public String getPathImage() {
3599 return _pathImage;
3600 }
3601
3602 @Override
3603 public String getPathMain() {
3604 return _pathMain;
3605 }
3606
3607 @Override
3608 public String getPathModule() {
3609 return _pathModule;
3610 }
3611
3612 @Override
3613 public String getPathProxy() {
3614 return _pathProxy;
3615 }
3616
3617 @Override
3618 public long getPlidFromFriendlyURL(long companyId, String friendlyURL) {
3619 if (Validator.isNull(friendlyURL)) {
3620 return LayoutConstants.DEFAULT_PLID;
3621 }
3622
3623 String[] urlParts = friendlyURL.split("\\/", 4);
3624
3625 if ((friendlyURL.charAt(0) != CharPool.SLASH) &&
3626 (urlParts.length != 4)) {
3627
3628 return LayoutConstants.DEFAULT_PLID;
3629 }
3630
3631 boolean privateLayout = true;
3632
3633 String urlPrefix = StringPool.SLASH + urlParts[1];
3634
3635 if (_PUBLIC_GROUP_SERVLET_MAPPING.equals(urlPrefix)) {
3636 privateLayout = false;
3637 }
3638 else if (_PRIVATE_GROUP_SERVLET_MAPPING.equals(urlPrefix) ||
3639 _PRIVATE_USER_SERVLET_MAPPING.equals(urlPrefix)) {
3640
3641 privateLayout = true;
3642 }
3643 else {
3644 return LayoutConstants.DEFAULT_PLID;
3645 }
3646
3647 Group group = null;
3648
3649 try {
3650 group = GroupLocalServiceUtil.getFriendlyURLGroup(
3651 companyId, StringPool.SLASH + urlParts[2]);
3652 }
3653 catch (Exception e) {
3654 }
3655
3656 if (group == null) {
3657 return LayoutConstants.DEFAULT_PLID;
3658 }
3659
3660 Layout layout = null;
3661
3662 try {
3663 String layoutFriendlyURL = null;
3664
3665 if (urlParts.length == 4) {
3666 layoutFriendlyURL = StringPool.SLASH + urlParts[3];
3667
3668 layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
3669 group.getGroupId(), privateLayout, layoutFriendlyURL);
3670 }
3671 else {
3672 List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
3673 group.getGroupId(), privateLayout,
3674 LayoutConstants.DEFAULT_PARENT_LAYOUT_ID, true, 0, 1);
3675
3676 if (!layouts.isEmpty()) {
3677 layout = layouts.get(0);
3678 }
3679 else {
3680 return LayoutConstants.DEFAULT_PLID;
3681 }
3682 }
3683
3684 return layout.getPlid();
3685 }
3686 catch (Exception e) {
3687 }
3688
3689 return LayoutConstants.DEFAULT_PLID;
3690 }
3691
3692 @Override
3693 public long getPlidFromPortletId(
3694 long groupId, boolean privateLayout, String portletId)
3695 throws PortalException, SystemException {
3696
3697 long plid = LayoutConstants.DEFAULT_PLID;
3698
3699 StringBundler sb = new StringBundler(5);
3700
3701 sb.append(groupId);
3702 sb.append(StringPool.SPACE);
3703 sb.append(privateLayout);
3704 sb.append(StringPool.SPACE);
3705 sb.append(portletId);
3706
3707 String key = sb.toString();
3708
3709 Long plidObj = _plidToPortletIdMap.get(key);
3710
3711 if (plidObj == null) {
3712 plid = doGetPlidFromPortletId(groupId, privateLayout, portletId);
3713
3714 if (plid != LayoutConstants.DEFAULT_PLID) {
3715 _plidToPortletIdMap.put(key, plid);
3716 }
3717 }
3718 else {
3719 plid = plidObj.longValue();
3720
3721 boolean validPlid = false;
3722
3723 try {
3724 Layout layout = LayoutLocalServiceUtil.getLayout(plid);
3725
3726 LayoutTypePortlet layoutTypePortlet =
3727 (LayoutTypePortlet)layout.getLayoutType();
3728
3729 if (layoutTypePortlet.hasDefaultScopePortletId(
3730 groupId, portletId)) {
3731
3732 validPlid = true;
3733 }
3734 }
3735 catch (Exception e) {
3736 }
3737
3738 if (!validPlid) {
3739 _plidToPortletIdMap.remove(key);
3740
3741 plid = doGetPlidFromPortletId(
3742 groupId, privateLayout, portletId);
3743
3744 if (plid != LayoutConstants.DEFAULT_PLID) {
3745 _plidToPortletIdMap.put(key, plid);
3746 }
3747 }
3748 }
3749
3750 return plid;
3751 }
3752
3753 @Override
3754 public long getPlidFromPortletId(long groupId, String portletId)
3755 throws PortalException, SystemException {
3756
3757 long plid = getPlidFromPortletId(groupId, false, portletId);
3758
3759 if (plid == LayoutConstants.DEFAULT_PLID) {
3760 plid = getPlidFromPortletId(groupId, true, portletId);
3761 }
3762
3763 if (plid == LayoutConstants.DEFAULT_PLID) {
3764 if (_log.isDebugEnabled()) {
3765 _log.debug(
3766 "Portlet " + portletId +
3767 " does not exist on a page in group " + groupId);
3768 }
3769 }
3770
3771 return plid;
3772 }
3773
3774 @Override
3775 public String getPortalLibDir() {
3776 return PropsValues.LIFERAY_LIB_PORTAL_DIR;
3777 }
3778
3779
3782 @Override
3783 public int getPortalPort() {
3784 return _portalPort.get();
3785 }
3786
3787 @Override
3788 public int getPortalPort(boolean secure) {
3789 if (secure) {
3790 return _securePortalPort.get();
3791 }
3792 else {
3793 return _portalPort.get();
3794 }
3795 }
3796
3797 @Override
3798 public Properties getPortalProperties() {
3799 return PropsUtil.getProperties();
3800 }
3801
3802 @Override
3803 public String getPortalURL(HttpServletRequest request) {
3804 return getPortalURL(request, isSecure(request));
3805 }
3806
3807 @Override
3808 public String getPortalURL(HttpServletRequest request, boolean secure) {
3809 return getPortalURL(
3810 request.getServerName(), request.getServerPort(), secure);
3811 }
3812
3813 @Override
3814 public String getPortalURL(Layout layout, ThemeDisplay themeDisplay)
3815 throws PortalException, SystemException {
3816
3817 String serverName = themeDisplay.getServerName();
3818
3819 if (layout == null) {
3820 layout = themeDisplay.getLayout();
3821 }
3822
3823 if (layout != null) {
3824 LayoutSet layoutSet = layout.getLayoutSet();
3825
3826 String virtualHostname = layoutSet.getVirtualHostname();
3827
3828 String domain = HttpUtil.getDomain(themeDisplay.getURLPortal());
3829
3830 if (Validator.isNotNull(virtualHostname) &&
3831 domain.startsWith(virtualHostname)) {
3832
3833 serverName = virtualHostname;
3834 }
3835 }
3836
3837 return getPortalURL(
3838 serverName, themeDisplay.getServerPort(), themeDisplay.isSecure());
3839 }
3840
3841 @Override
3842 public String getPortalURL(PortletRequest portletRequest) {
3843 return getPortalURL(portletRequest, portletRequest.isSecure());
3844 }
3845
3846 @Override
3847 public String getPortalURL(PortletRequest portletRequest, boolean secure) {
3848 return getPortalURL(
3849 portletRequest.getServerName(), portletRequest.getServerPort(),
3850 secure);
3851 }
3852
3853 @Override
3854 public String getPortalURL(
3855 String serverName, int serverPort, boolean secure) {
3856
3857 StringBundler sb = new StringBundler();
3858
3859 boolean https =
3860 (secure ||
3861 StringUtil.equalsIgnoreCase(
3862 Http.HTTPS, PropsValues.WEB_SERVER_PROTOCOL));
3863
3864 if (https) {
3865 sb.append(Http.HTTPS_WITH_SLASH);
3866 }
3867 else {
3868 sb.append(Http.HTTP_WITH_SLASH);
3869 }
3870
3871 if (Validator.isNull(PropsValues.WEB_SERVER_HOST)) {
3872 sb.append(serverName);
3873 }
3874 else {
3875 sb.append(PropsValues.WEB_SERVER_HOST);
3876 }
3877
3878 if (!https) {
3879 if (PropsValues.WEB_SERVER_HTTP_PORT == -1) {
3880 if ((serverPort != Http.HTTP_PORT) &&
3881 (serverPort != Http.HTTPS_PORT)) {
3882
3883 sb.append(StringPool.COLON);
3884 sb.append(serverPort);
3885 }
3886 }
3887 else {
3888 if (PropsValues.WEB_SERVER_HTTP_PORT != Http.HTTP_PORT) {
3889 sb.append(StringPool.COLON);
3890 sb.append(PropsValues.WEB_SERVER_HTTP_PORT);
3891 }
3892 }
3893 }
3894 else {
3895 if (PropsValues.WEB_SERVER_HTTPS_PORT == -1) {
3896 if ((serverPort != Http.HTTP_PORT) &&
3897 (serverPort != Http.HTTPS_PORT)) {
3898
3899 sb.append(StringPool.COLON);
3900 sb.append(serverPort);
3901 }
3902 }
3903 else {
3904 if (PropsValues.WEB_SERVER_HTTPS_PORT != Http.HTTPS_PORT) {
3905 sb.append(StringPool.COLON);
3906 sb.append(PropsValues.WEB_SERVER_HTTPS_PORT);
3907 }
3908 }
3909 }
3910
3911 return sb.toString();
3912 }
3913
3914 @Override
3915 public String getPortalURL(ThemeDisplay themeDisplay)
3916 throws PortalException, SystemException {
3917
3918 return getPortalURL(null, themeDisplay);
3919 }
3920
3921 @Override
3922 public String getPortalWebDir() {
3923 return PropsValues.LIFERAY_WEB_PORTAL_DIR;
3924 }
3925
3926
3930 @Override
3931 public Set<String> getPortletAddDefaultResourceCheckWhitelist() {
3932 return AuthTokenWhitelistUtil.getPortletInvocationWhitelist();
3933 }
3934
3935
3939 @Override
3940 public Set<String> getPortletAddDefaultResourceCheckWhitelistActions() {
3941 return AuthTokenWhitelistUtil.getPortletInvocationWhitelistActions();
3942 }
3943
3944
3948 @Override
3949 public List<BreadcrumbEntry> getPortletBreadcrumbList(
3950 HttpServletRequest request) {
3951
3952 return getPortletBreadcrumbs(request);
3953 }
3954
3955 @Override
3956 public List<BreadcrumbEntry> getPortletBreadcrumbs(
3957 HttpServletRequest request) {
3958
3959 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
3960 WebKeys.THEME_DISPLAY);
3961
3962 PortletDisplay portletDisplay = themeDisplay.getPortletDisplay();
3963
3964 String name = WebKeys.PORTLET_BREADCRUMBS;
3965
3966 String portletName = portletDisplay.getPortletName();
3967
3968 if (Validator.isNotNull(portletDisplay.getId()) &&
3969 !portletName.equals(PortletKeys.BREADCRUMB) &&
3970 !portletDisplay.isFocused()) {
3971
3972 name = name.concat(
3973 StringPool.UNDERLINE.concat(portletDisplay.getId()));
3974 }
3975
3976 return (List<BreadcrumbEntry>)request.getAttribute(name);
3977 }
3978
3979 @Override
3980 public PortletConfig getPortletConfig(
3981 long companyId, String portletId, ServletContext servletContext)
3982 throws PortletException, SystemException {
3983
3984 Portlet portlet = PortletLocalServiceUtil.getPortletById(
3985 companyId, portletId);
3986
3987 InvokerPortlet invokerPortlet = PortletInstanceFactoryUtil.create(
3988 portlet, servletContext);
3989
3990 return invokerPortlet.getPortletConfig();
3991 }
3992
3993 @Override
3994 public String getPortletDescription(
3995 Portlet portlet, ServletContext servletContext, Locale locale) {
3996
3997 PortletConfig portletConfig = PortletConfigFactoryUtil.create(
3998 portlet, servletContext);
3999
4000 ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
4001
4002 String portletDescription = ResourceBundleUtil.getString(
4003 resourceBundle,
4004 JavaConstants.JAVAX_PORTLET_DESCRIPTION.concat(
4005 StringPool.PERIOD).concat(portlet.getRootPortletId()));
4006
4007 if (Validator.isNull(portletDescription)) {
4008 portletDescription = ResourceBundleUtil.getString(
4009 resourceBundle, JavaConstants.JAVAX_PORTLET_DESCRIPTION);
4010 }
4011
4012 return portletDescription;
4013 }
4014
4015 @Override
4016 public String getPortletDescription(Portlet portlet, User user) {
4017 return getPortletDescription(portlet.getPortletId(), user);
4018 }
4019
4020 @Override
4021 public String getPortletDescription(String portletId, Locale locale) {
4022 return LanguageUtil.get(
4023 locale,
4024 JavaConstants.JAVAX_PORTLET_DESCRIPTION.concat(
4025 StringPool.PERIOD).concat(portletId));
4026 }
4027
4028 @Override
4029 public String getPortletDescription(String portletId, String languageId) {
4030 Locale locale = LocaleUtil.fromLanguageId(languageId);
4031
4032 return getPortletDescription(portletId, locale);
4033 }
4034
4035 @Override
4036 public String getPortletDescription(String portletId, User user) {
4037 return LanguageUtil.get(
4038 user.getLocale(),
4039 JavaConstants.JAVAX_PORTLET_DESCRIPTION.concat(
4040 StringPool.PERIOD).concat(portletId));
4041 }
4042
4043 public LayoutQueryStringComposite
4044 getPortletFriendlyURLMapperLayoutQueryStringComposite(
4045 long groupId, boolean privateLayout, String url,
4046 Map<String, String[]> params, Map<String, Object> requestContext)
4047 throws PortalException, SystemException {
4048
4049 boolean foundFriendlyURLMapper = false;
4050
4051 String friendlyURL = url;
4052 String queryString = StringPool.BLANK;
4053
4054 List<Portlet> portlets =
4055 PortletLocalServiceUtil.getFriendlyURLMapperPortlets();
4056
4057 for (Portlet portlet : portlets) {
4058 FriendlyURLMapper friendlyURLMapper =
4059 portlet.getFriendlyURLMapperInstance();
4060
4061 if (url.endsWith(
4062 StringPool.SLASH + friendlyURLMapper.getMapping())) {
4063
4064 url += StringPool.SLASH;
4065 }
4066
4067 int pos = -1;
4068
4069 if (friendlyURLMapper.isCheckMappingWithPrefix()) {
4070 pos = url.indexOf(
4071 FRIENDLY_URL_SEPARATOR + friendlyURLMapper.getMapping() +
4072 StringPool.SLASH);
4073 }
4074 else {
4075 pos = url.indexOf(
4076 StringPool.SLASH + friendlyURLMapper.getMapping() +
4077 StringPool.SLASH);
4078 }
4079
4080 if (pos != -1) {
4081 foundFriendlyURLMapper = true;
4082
4083 friendlyURL = url.substring(0, pos);
4084
4085 InheritableMap<String, String[]> actualParams =
4086 new InheritableMap<String, String[]>();
4087
4088 if (params != null) {
4089 actualParams.setParentMap(params);
4090 }
4091
4092 Map<String, String> prpIdentifiers =
4093 new HashMap<String, String>();
4094
4095 Set<PublicRenderParameter> publicRenderParameters =
4096 portlet.getPublicRenderParameters();
4097
4098 for (PublicRenderParameter publicRenderParameter :
4099 publicRenderParameters) {
4100
4101 QName qName = publicRenderParameter.getQName();
4102
4103 String publicRenderParameterIdentifier =
4104 qName.getLocalPart();
4105 String publicRenderParameterName =
4106 PortletQNameUtil.getPublicRenderParameterName(qName);
4107
4108 prpIdentifiers.put(
4109 publicRenderParameterIdentifier,
4110 publicRenderParameterName);
4111 }
4112
4113 FriendlyURLMapperThreadLocal.setPRPIdentifiers(prpIdentifiers);
4114
4115 if (friendlyURLMapper.isCheckMappingWithPrefix()) {
4116 friendlyURLMapper.populateParams(
4117 url.substring(pos + 2), actualParams, requestContext);
4118 }
4119 else {
4120 friendlyURLMapper.populateParams(
4121 url.substring(pos), actualParams, requestContext);
4122 }
4123
4124 queryString =
4125 StringPool.AMPERSAND +
4126 HttpUtil.parameterMapToString(actualParams, false);
4127
4128 break;
4129 }
4130 }
4131
4132 if (!foundFriendlyURLMapper) {
4133 int x = url.indexOf(FRIENDLY_URL_SEPARATOR);
4134
4135 if (x != -1) {
4136 int y = url.indexOf(CharPool.SLASH, x + 3);
4137
4138 if (y == -1) {
4139 y = url.length();
4140 }
4141
4142 String ppid = url.substring(x + 3, y);
4143
4144 if (Validator.isNotNull(ppid)) {
4145 friendlyURL = url.substring(0, x);
4146
4147 Map<String, String[]> actualParams = null;
4148
4149 if (params != null) {
4150 actualParams = new HashMap<String, String[]>(params);
4151 }
4152 else {
4153 actualParams = new HashMap<String, String[]>();
4154 }
4155
4156 actualParams.put("p_p_id", new String[] {ppid});
4157 actualParams.put("p_p_lifecycle", new String[] {"0"});
4158 actualParams.put(
4159 "p_p_state",
4160 new String[] {WindowState.MAXIMIZED.toString()});
4161 actualParams.put(
4162 "p_p_mode", new String[] {PortletMode.VIEW.toString()});
4163
4164 queryString =
4165 StringPool.AMPERSAND +
4166 HttpUtil.parameterMapToString(actualParams, false);
4167 }
4168 }
4169 }
4170
4171 friendlyURL = StringUtil.replace(
4172 friendlyURL, StringPool.DOUBLE_SLASH, StringPool.SLASH);
4173
4174 if (friendlyURL.endsWith(StringPool.SLASH)) {
4175 friendlyURL = friendlyURL.substring(0, friendlyURL.length() - 1);
4176 }
4177
4178 Layout layout = LayoutLocalServiceUtil.getFriendlyURLLayout(
4179 groupId, privateLayout, friendlyURL);
4180
4181 return new LayoutQueryStringComposite(layout, friendlyURL, queryString);
4182 }
4183
4184 @Override
4185 public String getPortletId(HttpServletRequest request) {
4186 LiferayPortletConfig liferayPortletConfig =
4187 (LiferayPortletConfig)request.getAttribute(
4188 JavaConstants.JAVAX_PORTLET_CONFIG);
4189
4190 if (liferayPortletConfig != null) {
4191 return liferayPortletConfig.getPortletId();
4192 }
4193 else {
4194 return null;
4195 }
4196 }
4197
4198 @Override
4199 public String getPortletId(PortletRequest portletRequest) {
4200 LiferayPortletConfig liferayPortletConfig =
4201 (LiferayPortletConfig)portletRequest.getAttribute(
4202 JavaConstants.JAVAX_PORTLET_CONFIG);
4203
4204 if (liferayPortletConfig != null) {
4205 return liferayPortletConfig.getPortletId();
4206 }
4207 else {
4208 return null;
4209 }
4210 }
4211
4212 @Override
4213 public String getPortletLongTitle(Portlet portlet, Locale locale) {
4214 return getPortletLongTitle(portlet.getPortletId(), locale);
4215 }
4216
4217 @Override
4218 public String getPortletLongTitle(
4219 Portlet portlet, ServletContext servletContext, Locale locale) {
4220
4221 PortletConfig portletConfig = PortletConfigFactoryUtil.create(
4222 portlet, servletContext);
4223
4224 ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
4225
4226 try {
4227 String portletLongTitle = resourceBundle.getString(
4228 JavaConstants.JAVAX_PORTLET_LONG_TITLE);
4229
4230 if (portletLongTitle.startsWith(
4231 JavaConstants.JAVAX_PORTLET_LONG_TITLE)) {
4232
4233 portletLongTitle = getPortletTitle(
4234 portlet, servletContext, locale);
4235 }
4236
4237 return portletLongTitle;
4238 }
4239 catch (Exception e) {
4240 return getPortletTitle(portlet, servletContext, locale);
4241 }
4242 }
4243
4244 @Override
4245 public String getPortletLongTitle(Portlet portlet, String languageId) {
4246 return getPortletLongTitle(portlet.getPortletId(), languageId);
4247 }
4248
4249 @Override
4250 public String getPortletLongTitle(Portlet portlet, User user) {
4251 return getPortletLongTitle(portlet.getPortletId(), user);
4252 }
4253
4254 @Override
4255 public String getPortletLongTitle(String portletId, Locale locale) {
4256 String portletLongTitle = LanguageUtil.get(
4257 locale,
4258 JavaConstants.JAVAX_PORTLET_LONG_TITLE.concat(
4259 StringPool.PERIOD).concat(portletId),
4260 StringPool.BLANK);
4261
4262 if (Validator.isNull(portletLongTitle)) {
4263 portletLongTitle = getPortletTitle(portletId, locale);
4264 }
4265
4266 return portletLongTitle;
4267 }
4268
4269 @Override
4270 public String getPortletLongTitle(String portletId, String languageId) {
4271 Locale locale = LocaleUtil.fromLanguageId(languageId);
4272
4273 return getPortletLongTitle(portletId, locale);
4274 }
4275
4276 @Override
4277 public String getPortletLongTitle(String portletId, User user) {
4278 return getPortletLongTitle(portletId, user.getLocale());
4279 }
4280
4281 @Override
4282 public String getPortletNamespace(String portletId) {
4283 return StringPool.UNDERLINE.concat(portletId).concat(
4284 StringPool.UNDERLINE);
4285 }
4286
4287 @Override
4288 public String getPortletTitle(Portlet portlet, Locale locale) {
4289 return getPortletTitle(portlet.getPortletId(), locale);
4290 }
4291
4292 @Override
4293 public String getPortletTitle(
4294 Portlet portlet, ServletContext servletContext, Locale locale) {
4295
4296 PortletConfig portletConfig = PortletConfigFactoryUtil.create(
4297 portlet, servletContext);
4298
4299 ResourceBundle resourceBundle = portletConfig.getResourceBundle(locale);
4300
4301 String portletTitle = ResourceBundleUtil.getString(
4302 resourceBundle,
4303 JavaConstants.JAVAX_PORTLET_TITLE.concat(StringPool.PERIOD).concat(
4304 portlet.getRootPortletId()));
4305
4306 if (Validator.isNull(portletTitle)) {
4307 portletTitle = ResourceBundleUtil.getString(
4308 resourceBundle, JavaConstants.JAVAX_PORTLET_TITLE);
4309 }
4310
4311 return portletTitle;
4312 }
4313
4314 @Override
4315 public String getPortletTitle(Portlet portlet, String languageId) {
4316 return getPortletTitle(portlet.getPortletId(), languageId);
4317 }
4318
4319 @Override
4320 public String getPortletTitle(Portlet portlet, User user) {
4321 return getPortletTitle(portlet.getPortletId(), user);
4322 }
4323
4324 @Override
4325 public String getPortletTitle(RenderRequest renderRequest) {
4326 String portletId = (String)renderRequest.getAttribute(
4327 WebKeys.PORTLET_ID);
4328
4329 Portlet portlet = PortletLocalServiceUtil.getPortletById(portletId);
4330
4331 HttpServletRequest request = getHttpServletRequest(renderRequest);
4332
4333 ServletContext servletContext = (ServletContext)request.getAttribute(
4334 WebKeys.CTX);
4335
4336 Locale locale = renderRequest.getLocale();
4337
4338 return getPortletTitle(portlet, servletContext, locale);
4339 }
4340
4341 @Override
4342 public String getPortletTitle(RenderResponse renderResponse) {
4343 PortletResponseImpl portletResponseImpl =
4344 PortletResponseImpl.getPortletResponseImpl(renderResponse);
4345
4346 return ((RenderResponseImpl)portletResponseImpl).getTitle();
4347 }
4348
4349 @Override
4350 public String getPortletTitle(String portletId, Locale locale) {
4351 return LanguageUtil.get(
4352 locale,
4353 JavaConstants.JAVAX_PORTLET_TITLE.concat(StringPool.PERIOD).concat(
4354 portletId));
4355 }
4356
4357 @Override
4358 public String getPortletTitle(String portletId, String languageId) {
4359 Locale locale = LocaleUtil.fromLanguageId(languageId);
4360
4361 return getPortletTitle(portletId, locale);
4362 }
4363
4364 @Override
4365 public String getPortletTitle(String portletId, User user) {
4366 return LanguageUtil.get(
4367 user.getLocale(),
4368 JavaConstants.JAVAX_PORTLET_TITLE.concat(StringPool.PERIOD).concat(
4369 portletId));
4370 }
4371
4372 @Override
4373 public String getPortletXmlFileName() throws SystemException {
4374 if (PrefsPropsUtil.getBoolean(
4375 PropsKeys.AUTO_DEPLOY_CUSTOM_PORTLET_XML,
4376 PropsValues.AUTO_DEPLOY_CUSTOM_PORTLET_XML)) {
4377
4378 return PORTLET_XML_FILE_NAME_CUSTOM;
4379 }
4380 else {
4381 return PORTLET_XML_FILE_NAME_STANDARD;
4382 }
4383 }
4384
4385 @Override
4386 public PortletPreferences getPreferences(HttpServletRequest request) {
4387 RenderRequest renderRequest = (RenderRequest)request.getAttribute(
4388 JavaConstants.JAVAX_PORTLET_REQUEST);
4389
4390 PortletPreferences portletPreferences = null;
4391
4392 if (renderRequest != null) {
4393 PortletPreferencesWrapper portletPreferencesWrapper =
4394 (PortletPreferencesWrapper)renderRequest.getPreferences();
4395
4396 portletPreferences =
4397 portletPreferencesWrapper.getPortletPreferencesImpl();
4398 }
4399
4400 return portletPreferences;
4401 }
4402
4403 @Override
4404 public PreferencesValidator getPreferencesValidator(Portlet portlet) {
4405 PortletBag portletBag = PortletBagPool.get(portlet.getRootPortletId());
4406
4407 return portletBag.getPreferencesValidatorInstance();
4408 }
4409
4410 @Override
4411 public String getRelativeHomeURL(HttpServletRequest request)
4412 throws PortalException, SystemException {
4413
4414 Company company = getCompany(request);
4415
4416 String homeURL = company.getHomeURL();
4417
4418 if (Validator.isNull(homeURL)) {
4419 homeURL = PropsValues.COMPANY_DEFAULT_HOME_URL;
4420 }
4421
4422 return homeURL;
4423 }
4424
4425 @Override
4426 public long getScopeGroupId(HttpServletRequest request)
4427 throws PortalException, SystemException {
4428
4429 String portletId = getPortletId(request);
4430
4431 return getScopeGroupId(request, portletId);
4432 }
4433
4434 @Override
4435 public long getScopeGroupId(HttpServletRequest request, String portletId)
4436 throws PortalException, SystemException {
4437
4438 return getScopeGroupId(request, portletId, false);
4439 }
4440
4441 @Override
4442 public long getScopeGroupId(
4443 HttpServletRequest request, String portletId,
4444 boolean checkStagingGroup)
4445 throws PortalException, SystemException {
4446
4447 Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
4448
4449 long scopeGroupId = 0;
4450
4451 if (layout != null) {
4452 Group group = layout.getGroup();
4453
4454 long doAsGroupId = ParamUtil.getLong(request, "doAsGroupId");
4455
4456 if (doAsGroupId <= 0) {
4457 HttpServletRequest originalRequest = getOriginalServletRequest(
4458 request);
4459
4460 doAsGroupId = ParamUtil.getLong(originalRequest, "doAsGroupId");
4461 }
4462
4463 Group doAsGroup = null;
4464
4465 if (doAsGroupId > 0) {
4466 doAsGroup = GroupLocalServiceUtil.fetchGroup(doAsGroupId);
4467 }
4468
4469 if (group.isControlPanel()) {
4470 if (doAsGroup == null) {
4471 doAsGroupId = getDefaultScopeGroupId(group.getCompanyId());
4472 }
4473
4474 if (doAsGroupId > 0) {
4475 scopeGroupId = doAsGroupId;
4476 }
4477
4478 group = GroupLocalServiceUtil.fetchGroup(scopeGroupId);
4479
4480 if ((group != null) && group.hasStagingGroup()) {
4481 try {
4482 Group stagingGroup = group.getStagingGroup();
4483
4484 scopeGroupId = stagingGroup.getGroupId();
4485 }
4486 catch (Exception e) {
4487 }
4488 }
4489 }
4490 else if (doAsGroup != null) {
4491 scopeGroupId = doAsGroupId;
4492 }
4493
4494 if ((portletId != null) && (group != null) &&
4495 (group.isStaged() || group.isStagingGroup())) {
4496
4497 Group liveGroup = group;
4498
4499 if (group.isStagingGroup()) {
4500 liveGroup = group.getLiveGroup();
4501 }
4502
4503 if (liveGroup.isStaged() &&
4504 !liveGroup.isStagedPortlet(portletId)) {
4505
4506 Layout liveGroupLayout =
4507 LayoutLocalServiceUtil.fetchLayoutByUuidAndGroupId(
4508 layout.getUuid(), liveGroup.getGroupId(),
4509 layout.isPrivateLayout());
4510
4511 if ((liveGroupLayout != null) &&
4512 liveGroupLayout.hasScopeGroup()) {
4513
4514 scopeGroupId = getScopeGroupId(
4515 liveGroupLayout, portletId);
4516 }
4517 else if (checkStagingGroup &&
4518 !liveGroup.isStagedRemotely()) {
4519
4520 Group stagingGroup = liveGroup.getStagingGroup();
4521
4522 scopeGroupId = stagingGroup.getGroupId();
4523 }
4524 else {
4525 scopeGroupId = liveGroup.getGroupId();
4526 }
4527 }
4528 }
4529 }
4530
4531 if (scopeGroupId <= 0) {
4532 scopeGroupId = getScopeGroupId(layout, portletId);
4533 }
4534
4535 return scopeGroupId;
4536 }
4537
4538 @Override
4539 public long getScopeGroupId(Layout layout) {
4540 if (layout == null) {
4541 return 0;
4542 }
4543 else {
4544 return layout.getGroupId();
4545 }
4546 }
4547
4548 @Override
4549 public long getScopeGroupId(Layout layout, String portletId) {
4550 if (layout == null) {
4551 return 0;
4552 }
4553
4554 if (Validator.isNull(portletId)) {
4555 return layout.getGroupId();
4556 }
4557
4558 try {
4559 PortletPreferences portletSetup =
4560 PortletPreferencesFactoryUtil.getStrictLayoutPortletSetup(
4561 layout, portletId);
4562
4563 String scopeType = GetterUtil.getString(
4564 portletSetup.getValue("lfrScopeType", null));
4565
4566 if (Validator.isNull(scopeType)) {
4567 return layout.getGroupId();
4568 }
4569
4570 if (scopeType.equals("company")) {
4571 Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
4572 layout.getCompanyId());
4573
4574 return companyGroup.getGroupId();
4575 }
4576
4577 String scopeLayoutUuid = GetterUtil.getString(
4578 portletSetup.getValue("lfrScopeLayoutUuid", null));
4579
4580 Layout scopeLayout =
4581 LayoutLocalServiceUtil.getLayoutByUuidAndGroupId(
4582 scopeLayoutUuid, layout.getGroupId(),
4583 layout.isPrivateLayout());
4584
4585 Group scopeGroup = scopeLayout.getScopeGroup();
4586
4587 return scopeGroup.getGroupId();
4588 }
4589 catch (Exception e) {
4590 return layout.getGroupId();
4591 }
4592 }
4593
4594 @Override
4595 public long getScopeGroupId(long plid) {
4596 Layout layout = null;
4597
4598 try {
4599 layout = LayoutLocalServiceUtil.getLayout(plid);
4600 }
4601 catch (Exception e) {
4602 }
4603
4604 return getScopeGroupId(layout);
4605 }
4606
4607 @Override
4608 public long getScopeGroupId(PortletRequest portletRequest)
4609 throws PortalException, SystemException {
4610
4611 return getScopeGroupId(getHttpServletRequest(portletRequest));
4612 }
4613
4614 @Override
4615 public User getSelectedUser(HttpServletRequest request)
4616 throws PortalException, SystemException {
4617
4618 return getSelectedUser(request, true);
4619 }
4620
4621 @Override
4622 public User getSelectedUser(
4623 HttpServletRequest request, boolean checkPermission)
4624 throws PortalException, SystemException {
4625
4626 long userId = ParamUtil.getLong(request, "p_u_i_d");
4627
4628 User user = null;
4629
4630 try {
4631 if (checkPermission) {
4632 user = UserServiceUtil.getUserById(userId);
4633 }
4634 else {
4635 user = UserLocalServiceUtil.getUserById(userId);
4636 }
4637 }
4638 catch (NoSuchUserException nsue) {
4639 }
4640
4641 return user;
4642 }
4643
4644 @Override
4645 public User getSelectedUser(PortletRequest portletRequest)
4646 throws PortalException, SystemException {
4647
4648 return getSelectedUser(portletRequest, true);
4649 }
4650
4651 @Override
4652 public User getSelectedUser(
4653 PortletRequest portletRequest, boolean checkPermission)
4654 throws PortalException, SystemException {
4655
4656 return getSelectedUser(
4657 getHttpServletRequest(portletRequest), checkPermission);
4658 }
4659
4660 @Override
4661 public String getServletContextName() {
4662 return _servletContextName;
4663 }
4664
4665 @Override
4666 public Map<String, List<Portlet>> getSiteAdministrationCategoriesMap(
4667 HttpServletRequest request)
4668 throws SystemException {
4669
4670 return getCategoriesMap(
4671 request, WebKeys.SITE_ADMINISTRATION_CATEGORIES_MAP,
4672 PortletCategoryKeys.SITE_ADMINISTRATION_ALL);
4673 }
4674
4675 @Override
4676 public long[] getSharedContentSiteGroupIds(
4677 long companyId, long groupId, long userId)
4678 throws PortalException, SystemException {
4679
4680 List<Group> groups = new UniqueList<Group>();
4681
4682 Group siteGroup = doGetCurrentSiteGroup(groupId);
4683
4684 if (siteGroup != null) {
4685
4686
4687
4688 groups.add(siteGroup);
4689
4690
4691
4692 groups.addAll(siteGroup.getChildren(true));
4693
4694
4695
4696 groups.addAll(
4697 GroupLocalServiceUtil.getGroups(
4698 siteGroup.getCompanyId(), Layout.class.getName(),
4699 siteGroup.getGroupId()));
4700 }
4701
4702
4703
4704 if (PrefsPropsUtil.getBoolean(
4705 companyId,
4706 PropsKeys.
4707 SITES_CONTENT_SHARING_THROUGH_ADMINISTRATORS_ENABLED)) {
4708
4709 LinkedHashMap<String, Object> groupParams =
4710 new LinkedHashMap<String, Object>();
4711
4712 groupParams.put("site", Boolean.TRUE);
4713 groupParams.put("usersGroups", userId);
4714
4715 groups.addAll(
4716 GroupLocalServiceUtil.search(
4717 companyId, null, null, groupParams, QueryUtil.ALL_POS,
4718 QueryUtil.ALL_POS, null));
4719 }
4720
4721
4722
4723 int sitesContentSharingWithChildrenEnabled = PrefsPropsUtil.getInteger(
4724 companyId, PropsKeys.SITES_CONTENT_SHARING_WITH_CHILDREN_ENABLED);
4725
4726 if (sitesContentSharingWithChildrenEnabled !=
4727 Sites.CONTENT_SHARING_WITH_CHILDREN_DISABLED) {
4728
4729 groups.addAll(doGetAncestorSiteGroups(groupId, true));
4730 }
4731
4732 long[] groupIds = new long[groups.size()];
4733
4734 for (int i = 0; i < groups.size(); i++) {
4735 Group group = groups.get(i);
4736
4737 groupIds[i] = group.getGroupId();
4738 }
4739
4740 return groupIds;
4741 }
4742
4743 @Override
4744 public PortletURL getSiteAdministrationURL(
4745 HttpServletRequest request, ThemeDisplay themeDisplay)
4746 throws SystemException {
4747
4748 Portlet portlet = getFirstSiteAdministrationPortlet(themeDisplay);
4749
4750 if (portlet == null) {
4751 return null;
4752 }
4753
4754 return getSiteAdministrationURL(
4755 request, themeDisplay, portlet.getPortletId());
4756 }
4757
4758 @Override
4759 public PortletURL getSiteAdministrationURL(
4760 HttpServletRequest request, ThemeDisplay themeDisplay,
4761 String portletId) {
4762
4763 LiferayPortletURL siteAdministrationURL = PortletURLFactoryUtil.create(
4764 request, portletId, themeDisplay.getPlid(),
4765 PortletRequest.RENDER_PHASE);
4766
4767 siteAdministrationURL.setControlPanelCategory(
4768 PortletCategoryKeys.SITES);
4769 siteAdministrationURL.setDoAsGroupId(themeDisplay.getScopeGroupId());
4770 siteAdministrationURL.setParameter(
4771 "redirect", themeDisplay.getURLCurrent());
4772
4773 return siteAdministrationURL;
4774 }
4775
4776 @Override
4777 public PortletURL getSiteAdministrationURL(
4778 PortletResponse portletResponse, ThemeDisplay themeDisplay)
4779 throws SystemException {
4780
4781 Portlet portlet = getFirstSiteAdministrationPortlet(themeDisplay);
4782
4783 if (portlet == null) {
4784 return null;
4785 }
4786
4787 return getSiteAdministrationURL(
4788 portletResponse, themeDisplay, portlet.getPortletId());
4789 }
4790
4791 @Override
4792 public PortletURL getSiteAdministrationURL(
4793 PortletResponse portletResponse, ThemeDisplay themeDisplay,
4794 String portletName) {
4795
4796 LiferayPortletResponse liferayPortletResponse =
4797 (LiferayPortletResponse)portletResponse;
4798
4799 LiferayPortletURL siteAdministrationURL =
4800 liferayPortletResponse.createRenderURL(portletName);
4801
4802 siteAdministrationURL.setControlPanelCategory(
4803 PortletCategoryKeys.SITES);
4804 siteAdministrationURL.setDoAsGroupId(themeDisplay.getScopeGroupId());
4805 siteAdministrationURL.setParameter(
4806 "redirect", themeDisplay.getURLCurrent());
4807
4808 return siteAdministrationURL;
4809 }
4810
4811 @Override
4812 public long[] getSiteAndCompanyGroupIds(long groupId)
4813 throws PortalException, SystemException {
4814
4815 Group scopeGroup = GroupLocalServiceUtil.getGroup(groupId);
4816
4817 if (scopeGroup.isCompany()) {
4818 return new long[] {groupId};
4819 }
4820
4821 Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
4822 scopeGroup.getCompanyId());
4823
4824 if (scopeGroup.isLayout()) {
4825 return new long[] {
4826 groupId, scopeGroup.getParentGroupId(),
4827 companyGroup.getGroupId()
4828 };
4829 }
4830 else if (scopeGroup.isLayoutSetPrototype() ||
4831 scopeGroup.isOrganization() || scopeGroup.isRegularSite() ||
4832 scopeGroup.isUser()) {
4833
4834 return new long[] {groupId, companyGroup.getGroupId()};
4835 }
4836 else {
4837 return new long[] {companyGroup.getGroupId()};
4838 }
4839 }
4840
4841 @Override
4842 public long[] getSiteAndCompanyGroupIds(ThemeDisplay themeDisplay)
4843 throws PortalException, SystemException {
4844
4845 return getSiteAndCompanyGroupIds(themeDisplay.getScopeGroupId());
4846 }
4847
4848 @Override
4849 public Locale getSiteDefaultLocale(long groupId)
4850 throws PortalException, SystemException {
4851
4852 if (groupId <= 0) {
4853 return LocaleUtil.getDefault();
4854 }
4855
4856 Group group = GroupLocalServiceUtil.getGroup(groupId);
4857
4858 Group liveGroup = group;
4859
4860 if (group.isStagingGroup()) {
4861 liveGroup = group.getLiveGroup();
4862 }
4863
4864 if (LanguageUtil.isInheritLocales(liveGroup.getGroupId())) {
4865 return LocaleUtil.getDefault();
4866 }
4867
4868 UnicodeProperties typeSettingsProperties =
4869 liveGroup.getTypeSettingsProperties();
4870
4871 User defaultUser = UserLocalServiceUtil.getDefaultUser(
4872 group.getCompanyId());
4873
4874 String languageId = GetterUtil.getString(
4875 typeSettingsProperties.getProperty("languageId"),
4876 defaultUser.getLanguageId());
4877
4878 return LocaleUtil.fromLanguageId(languageId);
4879 }
4880
4881 @Override
4882 public long getSiteGroupId(long groupId)
4883 throws PortalException, SystemException {
4884
4885 if (groupId <= 0) {
4886 return 0;
4887 }
4888
4889 Group group = GroupLocalServiceUtil.getGroup(groupId);
4890
4891 long siteGroupId = groupId;
4892
4893 if (group.isLayout()) {
4894 siteGroupId = group.getParentGroupId();
4895 }
4896
4897 return siteGroupId;
4898 }
4899
4900 @Override
4901 public String getSiteLoginURL(ThemeDisplay themeDisplay)
4902 throws PortalException, SystemException {
4903
4904 if (Validator.isNull(PropsValues.AUTH_LOGIN_SITE_URL)) {
4905 return null;
4906 }
4907
4908 List<Layout> layouts = themeDisplay.getUnfilteredLayouts();
4909
4910 if (layouts == null) {
4911 return null;
4912 }
4913
4914 for (Layout layout : layouts) {
4915 String friendlyURL = layout.getFriendlyURL(
4916 themeDisplay.getLocale());
4917
4918 if (friendlyURL.equals(PropsValues.AUTH_LOGIN_SITE_URL)) {
4919 if (themeDisplay.getLayout() == null) {
4920 break;
4921 }
4922
4923 String layoutSetFriendlyURL = getLayoutSetFriendlyURL(
4924 layout.getLayoutSet(), themeDisplay);
4925
4926 return layoutSetFriendlyURL + PropsValues.AUTH_LOGIN_SITE_URL;
4927 }
4928 }
4929
4930 return null;
4931 }
4932
4933 @Override
4934 public String getStaticResourceURL(HttpServletRequest request, String uri) {
4935 return getStaticResourceURL(request, uri, null, 0);
4936 }
4937
4938 @Override
4939 public String getStaticResourceURL(
4940 HttpServletRequest request, String uri, long timestamp) {
4941
4942 return getStaticResourceURL(request, uri, null, timestamp);
4943 }
4944
4945 @Override
4946 public String getStaticResourceURL(
4947 HttpServletRequest request, String uri, String queryString) {
4948
4949 return getStaticResourceURL(request, uri, queryString, 0);
4950 }
4951
4952 @Override
4953 public String getStaticResourceURL(
4954 HttpServletRequest request, String uri, String queryString,
4955 long timestamp) {
4956
4957 if (uri.indexOf(CharPool.QUESTION) != -1) {
4958 return uri;
4959 }
4960
4961 if (uri.startsWith(StringPool.DOUBLE_SLASH)) {
4962 uri = uri.substring(1);
4963 }
4964
4965 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
4966 WebKeys.THEME_DISPLAY);
4967
4968 Theme theme = themeDisplay.getTheme();
4969 ColorScheme colorScheme = themeDisplay.getColorScheme();
4970
4971 Map<String, String[]> parameterMap = null;
4972
4973 if (Validator.isNotNull(queryString)) {
4974 parameterMap = HttpUtil.getParameterMap(queryString);
4975 }
4976
4977 StringBundler sb = new StringBundler();
4978
4979
4980
4981 sb.append(uri);
4982 sb.append(StringPool.QUESTION);
4983
4984
4985
4986 if ((parameterMap == null) || !parameterMap.containsKey("browserId")) {
4987 sb.append("&browserId=");
4988 sb.append(BrowserSnifferUtil.getBrowserId(request));
4989 }
4990
4991
4992
4993 if ((uri.endsWith(".css") || uri.endsWith(".jsp")) &&
4994 ((parameterMap == null) || !parameterMap.containsKey("themeId"))) {
4995
4996 sb.append("&themeId=");
4997 sb.append(HttpUtil.encodeURL(theme.getThemeId()));
4998 }
4999
5000 if (uri.endsWith(".jsp") &&
5001 ((parameterMap == null) ||
5002 !parameterMap.containsKey("colorSchemeId"))) {
5003
5004 sb.append("&colorSchemeId=");
5005 sb.append(HttpUtil.encodeURL(colorScheme.getColorSchemeId()));
5006 }
5007
5008
5009
5010 if ((parameterMap == null) ||
5011 !parameterMap.containsKey("minifierType")) {
5012
5013 String minifierType = StringPool.BLANK;
5014
5015 if (uri.endsWith(".css") || uri.endsWith("css.jsp") ||
5016 (uri.endsWith(".jsp") && uri.contains("/css/"))) {
5017
5018 if (themeDisplay.isThemeCssFastLoad()) {
5019 minifierType = "css";
5020 }
5021 }
5022 else if (themeDisplay.isThemeJsFastLoad()) {
5023 minifierType = "js";
5024 }
5025
5026 if (Validator.isNotNull(minifierType)) {
5027 sb.append("&minifierType=");
5028 sb.append(minifierType);
5029 }
5030 }
5031
5032
5033
5034 if (Validator.isNotNull(queryString)) {
5035 if (!queryString.startsWith(StringPool.AMPERSAND)) {
5036 sb.append(StringPool.AMPERSAND);
5037 }
5038
5039 sb.append(queryString);
5040 }
5041
5042
5043
5044 sb.append("&languageId=");
5045 sb.append(themeDisplay.getLanguageId());
5046
5047
5048
5049 sb.append("&b=");
5050 sb.append(ReleaseInfo.getBuildNumber());
5051
5052
5053
5054 if ((parameterMap == null) || !parameterMap.containsKey("t")) {
5055 if ((timestamp == 0) && uri.startsWith(StrutsUtil.TEXT_HTML_DIR)) {
5056 ServletContext servletContext =
5057 (ServletContext)request.getAttribute(WebKeys.CTX);
5058
5059 timestamp = ServletContextUtil.getLastModified(
5060 servletContext, uri, true);
5061 }
5062
5063 if (timestamp == 0) {
5064 timestamp = theme.getTimestamp();
5065 }
5066
5067 sb.append("&t=");
5068 sb.append(timestamp);
5069 }
5070
5071 String url = sb.toString();
5072
5073 url = StringUtil.replace(url, "?&", StringPool.QUESTION);
5074
5075 return url;
5076 }
5077
5078 @Override
5079 public String getStrutsAction(HttpServletRequest request) {
5080 String strutsAction = ParamUtil.getString(request, "struts_action");
5081
5082 if (Validator.isNotNull(strutsAction)) {
5083
5084
5085
5086
5087
5088 return StringPool.BLANK;
5089 }
5090
5091 return getPortletParam(request, "struts_action");
5092 }
5093
5094 @Override
5095 public String[] getSystemGroups() {
5096 return _allSystemGroups;
5097 }
5098
5099 @Override
5100 public String[] getSystemOrganizationRoles() {
5101 return _allSystemOrganizationRoles;
5102 }
5103
5104 @Override
5105 public String[] getSystemRoles() {
5106 return _allSystemRoles;
5107 }
5108
5109 @Override
5110 public String[] getSystemSiteRoles() {
5111 return _allSystemSiteRoles;
5112 }
5113
5114 @Override
5115 public String getUniqueElementId(
5116 HttpServletRequest request, String namespace, String elementId) {
5117
5118 String uniqueElementId = elementId;
5119
5120 Set<String> uniqueElementIds = (Set<String>)request.getAttribute(
5121 WebKeys.UNIQUE_ELEMENT_IDS);
5122
5123 if (uniqueElementIds == null) {
5124 uniqueElementIds = new ConcurrentHashSet<String>();
5125
5126 request.setAttribute(WebKeys.UNIQUE_ELEMENT_IDS, uniqueElementIds);
5127 }
5128 else {
5129 int i = 1;
5130
5131 while (uniqueElementIds.contains(
5132 namespace.concat(uniqueElementId))) {
5133
5134 if (Validator.isNull(elementId) ||
5135 elementId.endsWith(StringPool.UNDERLINE)) {
5136
5137 uniqueElementId = elementId.concat(String.valueOf(i));
5138 }
5139 else {
5140 uniqueElementId =
5141 elementId.concat(StringPool.UNDERLINE).concat(
5142 String.valueOf(i));
5143 }
5144
5145 i++;
5146 }
5147 }
5148
5149 uniqueElementIds.add(namespace.concat(uniqueElementId));
5150
5151 return uniqueElementId;
5152 }
5153
5154 @Override
5155 public String getUniqueElementId(
5156 PortletRequest request, String namespace, String elementId) {
5157
5158 return getUniqueElementId(
5159 getHttpServletRequest(request), namespace, elementId);
5160 }
5161
5162 @Override
5163 public UploadPortletRequest getUploadPortletRequest(
5164 PortletRequest portletRequest) {
5165
5166 PortletRequestImpl portletRequestImpl =
5167 PortletRequestImpl.getPortletRequestImpl(portletRequest);
5168
5169 DynamicServletRequest dynamicRequest =
5170 (DynamicServletRequest)portletRequestImpl.getHttpServletRequest();
5171
5172 HttpServletRequestWrapper requestWrapper =
5173 (HttpServletRequestWrapper)dynamicRequest.getRequest();
5174
5175 UploadServletRequest uploadServletRequest = getUploadServletRequest(
5176 requestWrapper);
5177
5178 return new UploadPortletRequestImpl(
5179 uploadServletRequest, portletRequestImpl,
5180 getPortletNamespace(portletRequestImpl.getPortletName()));
5181 }
5182
5183 @Override
5184 public UploadServletRequest getUploadServletRequest(
5185 HttpServletRequest request) {
5186
5187 List<PersistentHttpServletRequestWrapper>
5188 persistentHttpServletRequestWrappers =
5189 new ArrayList<PersistentHttpServletRequestWrapper>();
5190
5191 HttpServletRequest currentRequest = request;
5192
5193 while (currentRequest instanceof HttpServletRequestWrapper) {
5194 if (currentRequest instanceof UploadServletRequest) {
5195 return (UploadServletRequest)currentRequest;
5196 }
5197
5198 if (currentRequest instanceof
5199 PersistentHttpServletRequestWrapper) {
5200
5201 PersistentHttpServletRequestWrapper
5202 persistentHttpServletRequestWrapper =
5203 (PersistentHttpServletRequestWrapper)currentRequest;
5204
5205 persistentHttpServletRequestWrappers.add(
5206 persistentHttpServletRequestWrapper.clone());
5207 }
5208
5209 HttpServletRequestWrapper httpServletRequestWrapper =
5210 (HttpServletRequestWrapper)currentRequest;
5211
5212 currentRequest =
5213 (HttpServletRequest)httpServletRequestWrapper.getRequest();
5214 }
5215
5216 if (ServerDetector.isWebLogic()) {
5217 currentRequest = new NonSerializableObjectRequestWrapper(
5218 currentRequest);
5219 }
5220
5221 for (int i = persistentHttpServletRequestWrappers.size() - 1; i >= 0;
5222 i--) {
5223
5224 HttpServletRequestWrapper httpServletRequestWrapper =
5225 persistentHttpServletRequestWrappers.get(i);
5226
5227 httpServletRequestWrapper.setRequest(currentRequest);
5228
5229 currentRequest = httpServletRequestWrapper;
5230 }
5231
5232 return new UploadServletRequestImpl(currentRequest);
5233 }
5234
5235 @Override
5236 public Date getUptime() {
5237 return _upTime;
5238 }
5239
5240 @Override
5241 public String getURLWithSessionId(String url, String sessionId) {
5242 if (!PropsValues.SESSION_ENABLE_URL_WITH_SESSION_ID) {
5243 return url;
5244 }
5245
5246 if (Validator.isNull(url)) {
5247 return url;
5248 }
5249
5250
5251
5252 int x = url.indexOf(CharPool.SEMICOLON);
5253
5254 if (x != -1) {
5255 return url;
5256 }
5257
5258 x = url.indexOf(CharPool.QUESTION);
5259
5260 if (x != -1) {
5261 StringBundler sb = new StringBundler(4);
5262
5263 sb.append(url.substring(0, x));
5264 sb.append(JSESSIONID);
5265 sb.append(sessionId);
5266 sb.append(url.substring(x));
5267
5268 return sb.toString();
5269 }
5270
5271
5272
5273
5274 x = url.indexOf(StringPool.DOUBLE_SLASH);
5275
5276 StringBundler sb = new StringBundler(4);
5277
5278 sb.append(url);
5279
5280 if (x != -1) {
5281 int y = url.lastIndexOf(CharPool.SLASH);
5282
5283 if ((x + 1) == y) {
5284 sb.append(StringPool.SLASH);
5285 }
5286 }
5287
5288 sb.append(JSESSIONID);
5289 sb.append(sessionId);
5290
5291 return sb.toString();
5292 }
5293
5294 @Override
5295 public User getUser(HttpServletRequest request)
5296 throws PortalException, SystemException {
5297
5298 User user = (User)request.getAttribute(WebKeys.USER);
5299
5300 if (user != null) {
5301 return user;
5302 }
5303
5304 long userId = getUserId(request);
5305
5306 if (userId <= 0) {
5307
5308
5309
5310
5311
5312
5313 String remoteUser = request.getRemoteUser();
5314
5315 if (remoteUser == null) {
5316 return null;
5317 }
5318
5319 userId = GetterUtil.getLong(remoteUser);
5320 }
5321
5322 if (userId > 0) {
5323 user = UserLocalServiceUtil.getUserById(userId);
5324
5325 request.setAttribute(WebKeys.USER, user);
5326 }
5327
5328 Cookie[] cookies = request.getCookies();
5329
5330 if (cookies != null) {
5331 for (Cookie cookie : cookies) {
5332 String cookieName = cookie.getName();
5333
5334 if (cookieName.startsWith(
5335 CookieKeys.REMOTE_PREFERENCE_PREFIX)) {
5336
5337 user.addRemotePreference(
5338 new CookieRemotePreference(cookie));
5339 }
5340 }
5341 }
5342
5343 return user;
5344 }
5345
5346 @Override
5347 public User getUser(PortletRequest portletRequest)
5348 throws PortalException, SystemException {
5349
5350 return getUser(getHttpServletRequest(portletRequest));
5351 }
5352
5353 @Override
5354 public String getUserEmailAddress(long userId) throws SystemException {
5355 try {
5356 User user = UserLocalServiceUtil.getUserById(userId);
5357
5358 return user.getEmailAddress();
5359 }
5360 catch (PortalException pe) {
5361 return StringPool.BLANK;
5362 }
5363 }
5364
5365 @Override
5366 public long getUserId(HttpServletRequest request) {
5367 Long userIdObj = (Long)request.getAttribute(WebKeys.USER_ID);
5368
5369 if (userIdObj != null) {
5370 return userIdObj.longValue();
5371 }
5372
5373 String path = GetterUtil.getString(request.getPathInfo());
5374 String strutsAction = getStrutsAction(request);
5375 String actionName = getPortletParam(request, "actionName");
5376
5377 boolean alwaysAllowDoAsUser = false;
5378
5379 if (path.equals("/portal/session_click") ||
5380 strutsAction.equals("/document_library/edit_file_entry") ||
5381 strutsAction.equals("/document_library_display/edit_file_entry") ||
5382 strutsAction.equals("/image_gallery_display/edit_file_entry") ||
5383 strutsAction.equals("/image_gallery_display/edit_image") ||
5384 strutsAction.equals("/wiki/edit_page_attachment") ||
5385 strutsAction.equals("/wiki_admin/edit_page_attachment") ||
5386 strutsAction.equals("/wiki_display/edit_page_attachment") ||
5387 actionName.equals("addFile")) {
5388
5389 try {
5390 alwaysAllowDoAsUser = isAlwaysAllowDoAsUser(request);
5391 }
5392 catch (Exception e) {
5393 _log.error(e, e);
5394 }
5395 }
5396
5397 if ((!PropsValues.PORTAL_JAAS_ENABLE &&
5398 PropsValues.PORTAL_IMPERSONATION_ENABLE) ||
5399 alwaysAllowDoAsUser) {
5400
5401 String doAsUserIdString = ParamUtil.getString(
5402 request, "doAsUserId");
5403
5404 try {
5405 long doAsUserId = getDoAsUserId(
5406 request, doAsUserIdString, alwaysAllowDoAsUser);
5407
5408 if (doAsUserId > 0) {
5409 if (_log.isDebugEnabled()) {
5410 _log.debug("Impersonating user " + doAsUserId);
5411 }
5412
5413 return doAsUserId;
5414 }
5415 }
5416 catch (Exception e) {
5417 _log.error("Unable to impersonate user " + doAsUserIdString, e);
5418 }
5419 }
5420
5421 HttpSession session = request.getSession();
5422
5423 userIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
5424
5425 if (userIdObj != null) {
5426 request.setAttribute(WebKeys.USER_ID, userIdObj);
5427
5428 return userIdObj.longValue();
5429 }
5430 else {
5431 return 0;
5432 }
5433 }
5434
5435 @Override
5436 public long getUserId(PortletRequest portletRequest) {
5437 return getUserId(getHttpServletRequest(portletRequest));
5438 }
5439
5440 @Override
5441 public String getUserName(BaseModel<?> baseModel) {
5442 long userId = 0;
5443 String userName = StringPool.BLANK;
5444
5445 if (baseModel instanceof AuditedModel) {
5446 AuditedModel auditedModel = (AuditedModel)baseModel;
5447
5448 userId = auditedModel.getUserId();
5449 userName = auditedModel.getUserName();
5450 }
5451 else {
5452 userId = BeanPropertiesUtil.getLongSilent(baseModel, "userId");
5453 userName = BeanPropertiesUtil.getStringSilent(
5454 baseModel, "userName");
5455 }
5456
5457 if (userId == 0) {
5458 return StringPool.BLANK;
5459 }
5460
5461 if (baseModel.isEscapedModel()) {
5462 userName = HtmlUtil.unescape(userName);
5463 }
5464
5465 userName = getUserName(userId, userName);
5466
5467 if (baseModel.isEscapedModel()) {
5468 userName = HtmlUtil.escape(userName);
5469 }
5470
5471 return userName;
5472 }
5473
5474 @Override
5475 public String getUserName(long userId, String defaultUserName) {
5476 return getUserName(
5477 userId, defaultUserName, UserAttributes.USER_NAME_FULL);
5478 }
5479
5480 @Override
5481 public String getUserName(
5482 long userId, String defaultUserName, HttpServletRequest request) {
5483
5484 return getUserName(
5485 userId, defaultUserName, UserAttributes.USER_NAME_FULL, request);
5486 }
5487
5488 @Override
5489 public String getUserName(
5490 long userId, String defaultUserName, String userAttribute) {
5491
5492 return getUserName(userId, defaultUserName, userAttribute, null);
5493 }
5494
5495 @Override
5496 public String getUserName(
5497 long userId, String defaultUserName, String userAttribute,
5498 HttpServletRequest request) {
5499
5500 String userName = defaultUserName;
5501
5502 try {
5503 User user = UserLocalServiceUtil.getUserById(userId);
5504
5505 if (userAttribute.equals(UserAttributes.USER_NAME_FULL)) {
5506 userName = user.getFullName();
5507 }
5508 else {
5509 userName = user.getScreenName();
5510 }
5511
5512 if (request != null) {
5513 Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
5514
5515 PortletURL portletURL = new PortletURLImpl(
5516 request, PortletKeys.DIRECTORY, layout.getPlid(),
5517 PortletRequest.RENDER_PHASE);
5518
5519 portletURL.setParameter(
5520 "struts_action", "/directory/view_user");
5521 portletURL.setParameter(
5522 "p_u_i_d", String.valueOf(user.getUserId()));
5523 portletURL.setPortletMode(PortletMode.VIEW);
5524 portletURL.setWindowState(WindowState.MAXIMIZED);
5525
5526 userName =
5527 "<a href=\"" + portletURL.toString() + "\">" +
5528 HtmlUtil.escape(userName) + "</a>";
5529 }
5530 }
5531 catch (Exception e) {
5532 }
5533
5534 return userName;
5535 }
5536
5537 @Override
5538 public String getUserPassword(HttpServletRequest request) {
5539 HttpSession session = request.getSession();
5540
5541 return getUserPassword(session);
5542 }
5543
5544 @Override
5545 public String getUserPassword(HttpSession session) {
5546 return (String)session.getAttribute(WebKeys.USER_PASSWORD);
5547 }
5548
5549 @Override
5550 public String getUserPassword(PortletRequest portletRequest) {
5551 return getUserPassword(getHttpServletRequest(portletRequest));
5552 }
5553
5554 @Override
5555 public String getUserValue(long userId, String param, String defaultValue)
5556 throws SystemException {
5557
5558 if (Validator.isNotNull(defaultValue)) {
5559 return defaultValue;
5560 }
5561
5562 try {
5563 User user = UserLocalServiceUtil.getUserById(userId);
5564
5565 return BeanPropertiesUtil.getString(user, param, defaultValue);
5566 }
5567 catch (PortalException pe) {
5568 return StringPool.BLANK;
5569 }
5570 }
5571
5572 @Override
5573 public String getValidPortalDomain(long companyId, String domain) {
5574 if (_validPortalDomainCheckDisabled) {
5575 return domain;
5576 }
5577
5578 for (String virtualHost : PropsValues.VIRTUAL_HOSTS_VALID_HOSTS) {
5579 if (StringUtil.equalsIgnoreCase(domain, virtualHost) ||
5580 StringUtil.wildcardMatches(
5581 domain, virtualHost, CharPool.QUESTION, CharPool.STAR,
5582 CharPool.PERCENT, false)) {
5583
5584 return domain;
5585 }
5586 }
5587
5588 if (_log.isWarnEnabled()) {
5589 _log.warn(
5590 "Set the property \"" + PropsKeys.VIRTUAL_HOSTS_VALID_HOSTS +
5591 "\" in portal.properties to allow \"" + domain +
5592 "\" as a domain");
5593 }
5594
5595 try {
5596 Company company = CompanyLocalServiceUtil.getCompanyById(
5597 getDefaultCompanyId());
5598
5599 return company.getVirtualHostname();
5600 }
5601 catch (Exception e) {
5602 _log.error("Unable to load default portal instance", e);
5603 }
5604
5605 return _LOCALHOST;
5606 }
5607
5608 @Override
5609 public long getValidUserId(long companyId, long userId)
5610 throws PortalException, SystemException {
5611
5612 User user = UserLocalServiceUtil.fetchUser(userId);
5613
5614 if (user == null) {
5615 return UserLocalServiceUtil.getDefaultUserId(companyId);
5616 }
5617
5618 if (user.getCompanyId() == companyId) {
5619 return user.getUserId();
5620 }
5621
5622 return userId;
5623 }
5624
5625 @Override
5626 public String getVirtualLayoutActualURL(
5627 long groupId, boolean privateLayout, String mainPath,
5628 String friendlyURL, Map<String, String[]> params,
5629 Map<String, Object> requestContext)
5630 throws PortalException, SystemException {
5631
5632
5633
5634 String groupFriendlyURL = null;
5635
5636 int pos = friendlyURL.indexOf(CharPool.SLASH, 3);
5637
5638 if (pos != -1) {
5639 groupFriendlyURL = friendlyURL.substring(2, pos);
5640 }
5641
5642 if (Validator.isNull(groupFriendlyURL)) {
5643 return mainPath;
5644 }
5645
5646 HttpServletRequest request = (HttpServletRequest)requestContext.get(
5647 "request");
5648
5649 long companyId = PortalInstances.getCompanyId(request);
5650
5651 Group group = GroupLocalServiceUtil.fetchFriendlyURLGroup(
5652 companyId, groupFriendlyURL);
5653
5654 if (group == null) {
5655 return mainPath;
5656 }
5657
5658
5659
5660 String layoutFriendlyURL = null;
5661
5662 if ((pos != -1) && ((pos + 1) != friendlyURL.length())) {
5663 layoutFriendlyURL = friendlyURL.substring(pos);
5664 }
5665
5666 if (Validator.isNull(layoutFriendlyURL)) {
5667 return mainPath;
5668 }
5669
5670 String actualURL = getActualURL(
5671 group.getGroupId(), privateLayout, mainPath, layoutFriendlyURL,
5672 params, requestContext);
5673
5674 return HttpUtil.addParameter(
5675 HttpUtil.removeParameter(actualURL, "p_v_l_s_g_id"), "p_v_l_s_g_id",
5676 groupId);
5677 }
5678
5679 @Override
5680 public LayoutFriendlyURLComposite getVirtualLayoutFriendlyURLComposite(
5681 boolean privateLayout, String friendlyURL,
5682 Map<String, String[]> params, Map<String, Object> requestContext)
5683 throws PortalException, SystemException {
5684
5685
5686
5687 String groupFriendlyURL = null;
5688
5689 int pos = friendlyURL.indexOf(CharPool.SLASH, 3);
5690
5691 if (pos != -1) {
5692 groupFriendlyURL = friendlyURL.substring(2, pos);
5693 }
5694
5695 HttpServletRequest request = (HttpServletRequest)requestContext.get(
5696 "request");
5697
5698 long companyId = PortalInstances.getCompanyId(request);
5699
5700 Group group = GroupLocalServiceUtil.fetchFriendlyURLGroup(
5701 companyId, groupFriendlyURL);
5702
5703
5704
5705 String layoutFriendlyURL = null;
5706
5707 if ((pos != -1) && ((pos + 1) != friendlyURL.length())) {
5708 layoutFriendlyURL = friendlyURL.substring(pos);
5709 }
5710
5711 LayoutQueryStringComposite layoutQueryStringComposite =
5712 getActualLayoutQueryStringComposite(
5713 group.getGroupId(), privateLayout, layoutFriendlyURL, params,
5714 requestContext);
5715
5716 return new LayoutFriendlyURLComposite(
5717 layoutQueryStringComposite.getLayout(), layoutFriendlyURL);
5718 }
5719
5720 @Override
5721 public String getWidgetURL(Portlet portlet, ThemeDisplay themeDisplay)
5722 throws PortalException, SystemException {
5723
5724 return getServletURL(
5725 portlet, PropsValues.WIDGET_SERVLET_MAPPING, themeDisplay);
5726 }
5727
5728 @Override
5729 public void initCustomSQL() {
5730 _customSqlKeys = new String[] {
5731 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.GROUP$]",
5732 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.LAYOUT$]",
5733 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ORGANIZATION$]",
5734 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ROLE$]",
5735 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USER$]",
5736 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USERGROUP$]",
5737 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BLOGS.MODEL.BLOGSENTRY$]",
5738 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BOOKMARKS.MODEL." +
5739 "BOOKMARKSENTRY$]",
5740 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BOOKMARKS.MODEL." +
5741 "BOOKMARKSFOLDER$]",
5742 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.CALENDAR.MODEL.CALEVENT$]",
5743 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.DOCUMENTLIBRARY.MODEL." +
5744 "DLFILEENTRY$]",
5745 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.DOCUMENTLIBRARY.MODEL." +
5746 "DLFOLDER$]",
5747 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.JOURNAL.MODEL." +
5748 "JOURNALFOLDER$]",
5749 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.MESSAGEBOARDS.MODEL." +
5750 "MBMESSAGE$]",
5751 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.MESSAGEBOARDS.MODEL." +
5752 "MBTHREAD$]",
5753 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.WIKI.MODEL.WIKIPAGE$]",
5754 "[$RESOURCE_SCOPE_COMPANY$]", "[$RESOURCE_SCOPE_GROUP$]",
5755 "[$RESOURCE_SCOPE_GROUP_TEMPLATE$]",
5756 "[$RESOURCE_SCOPE_INDIVIDUAL$]",
5757 "[$SOCIAL_RELATION_TYPE_BI_COWORKER$]",
5758 "[$SOCIAL_RELATION_TYPE_BI_FRIEND$]",
5759 "[$SOCIAL_RELATION_TYPE_BI_ROMANTIC_PARTNER$]",
5760 "[$SOCIAL_RELATION_TYPE_BI_SIBLING$]",
5761 "[$SOCIAL_RELATION_TYPE_BI_SPOUSE$]",
5762 "[$SOCIAL_RELATION_TYPE_UNI_CHILD$]",
5763 "[$SOCIAL_RELATION_TYPE_UNI_ENEMY$]",
5764 "[$SOCIAL_RELATION_TYPE_UNI_FOLLOWER$]",
5765 "[$SOCIAL_RELATION_TYPE_UNI_PARENT$]",
5766 "[$SOCIAL_RELATION_TYPE_UNI_SUBORDINATE$]",
5767 "[$SOCIAL_RELATION_TYPE_UNI_SUPERVISOR$]", "[$FALSE$]", "[$TRUE$]"
5768 };
5769
5770 DB db = DBFactoryUtil.getDB();
5771
5772 Object[] customSqlValues = new Object[] {
5773 getClassNameId(Group.class), getClassNameId(Layout.class),
5774 getClassNameId(Organization.class), getClassNameId(Role.class),
5775 getClassNameId(User.class), getClassNameId(UserGroup.class),
5776 getClassNameId(BlogsEntry.class),
5777 getClassNameId(BookmarksEntry.class),
5778 getClassNameId(BookmarksFolder.class),
5779 getClassNameId(CalEvent.class), getClassNameId(DLFileEntry.class),
5780 getClassNameId(DLFolder.class), getClassNameId(JournalFolder.class),
5781 getClassNameId(MBMessage.class), getClassNameId(MBThread.class),
5782 getClassNameId(WikiPage.class), ResourceConstants.SCOPE_COMPANY,
5783 ResourceConstants.SCOPE_GROUP,
5784 ResourceConstants.SCOPE_GROUP_TEMPLATE,
5785 ResourceConstants.SCOPE_INDIVIDUAL,
5786 SocialRelationConstants.TYPE_BI_COWORKER,
5787 SocialRelationConstants.TYPE_BI_FRIEND,
5788 SocialRelationConstants.TYPE_BI_ROMANTIC_PARTNER,
5789 SocialRelationConstants.TYPE_BI_SIBLING,
5790 SocialRelationConstants.TYPE_BI_SPOUSE,
5791 SocialRelationConstants.TYPE_UNI_CHILD,
5792 SocialRelationConstants.TYPE_UNI_ENEMY,
5793 SocialRelationConstants.TYPE_UNI_FOLLOWER,
5794 SocialRelationConstants.TYPE_UNI_PARENT,
5795 SocialRelationConstants.TYPE_UNI_SUBORDINATE,
5796 SocialRelationConstants.TYPE_UNI_SUPERVISOR, db.getTemplateFalse(),
5797 db.getTemplateTrue()
5798 };
5799
5800 _customSqlValues = ArrayUtil.toStringArray(customSqlValues);
5801 }
5802
5803 @Override
5804 public User initUser(HttpServletRequest request) throws Exception {
5805 User user = null;
5806
5807 try {
5808 user = getUser(request);
5809 }
5810 catch (NoSuchUserException nsue) {
5811 if (_log.isWarnEnabled()) {
5812 _log.warn(nsue.getMessage());
5813 }
5814
5815 long userId = getUserId(request);
5816
5817 if (userId > 0) {
5818 HttpSession session = request.getSession();
5819
5820 session.invalidate();
5821 }
5822
5823 throw nsue;
5824 }
5825
5826 if (user != null) {
5827 return user;
5828 }
5829
5830 Company company = getCompany(request);
5831
5832 return company.getDefaultUser();
5833 }
5834
5835 @Override
5836 public void invokeTaglibDiscussion(
5837 PortletConfig portletConfig, ActionRequest actionRequest,
5838 ActionResponse actionResponse)
5839 throws Exception {
5840
5841 _editDiscussionAction.processAction(
5842 null, null, portletConfig, actionRequest, actionResponse);
5843 }
5844
5845
5848 @Override
5849 public boolean isAllowAddPortletDefaultResource(
5850 HttpServletRequest request, Portlet portlet)
5851 throws PortalException, SystemException {
5852
5853 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
5854 WebKeys.THEME_DISPLAY);
5855
5856 Layout layout = themeDisplay.getLayout();
5857 LayoutTypePortlet layoutTypePortlet =
5858 themeDisplay.getLayoutTypePortlet();
5859
5860 String portletId = portlet.getPortletId();
5861
5862 Boolean renderPortletResource = (Boolean)request.getAttribute(
5863 WebKeys.RENDER_PORTLET_RESOURCE);
5864
5865 if (renderPortletResource != null) {
5866 boolean runtimePortlet = renderPortletResource.booleanValue();
5867
5868 if (runtimePortlet) {
5869 return true;
5870 }
5871 }
5872
5873 if (layout.isTypePanel() &&
5874 isPanelSelectedPortlet(themeDisplay, portletId)) {
5875
5876 return true;
5877 }
5878
5879 if (layout.isTypeControlPanel() &&
5880 isControlPanelPortlet(portletId, themeDisplay)) {
5881
5882 return true;
5883 }
5884
5885 if ((layoutTypePortlet != null) &&
5886 layoutTypePortlet.hasPortletId(portletId)) {
5887
5888 return true;
5889 }
5890
5891 if (themeDisplay.isSignedIn() &&
5892 portletId.equals(PortletKeys.LAYOUTS_ADMIN)) {
5893
5894 PermissionChecker permissionChecker =
5895 themeDisplay.getPermissionChecker();
5896
5897 Group group = layout.getGroup();
5898
5899 if (group.isSite()) {
5900 if (LayoutPermissionUtil.contains(
5901 permissionChecker, layout, ActionKeys.CUSTOMIZE) ||
5902 LayoutPermissionUtil.contains(
5903 permissionChecker, layout, ActionKeys.UPDATE)) {
5904
5905 return true;
5906 }
5907 }
5908
5909 if (group.isCompany()) {
5910 if (permissionChecker.isCompanyAdmin()) {
5911 return true;
5912 }
5913 }
5914 else if (group.isLayoutPrototype()) {
5915 long layoutPrototypeId = group.getClassPK();
5916
5917 if (LayoutPrototypePermissionUtil.contains(
5918 permissionChecker, layoutPrototypeId,
5919 ActionKeys.UPDATE)) {
5920
5921 return true;
5922 }
5923 }
5924 else if (group.isLayoutSetPrototype()) {
5925 long layoutSetPrototypeId = group.getClassPK();
5926
5927 if (LayoutSetPrototypePermissionUtil.contains(
5928 permissionChecker, layoutSetPrototypeId,
5929 ActionKeys.UPDATE)) {
5930
5931 return true;
5932 }
5933 }
5934 else if (group.isOrganization()) {
5935 long organizationId = group.getOrganizationId();
5936
5937 if (OrganizationPermissionUtil.contains(
5938 permissionChecker, organizationId, ActionKeys.UPDATE)) {
5939
5940 return true;
5941 }
5942 }
5943 else if (group.isUserGroup()) {
5944 long scopeGroupId = themeDisplay.getScopeGroupId();
5945
5946 if (GroupPermissionUtil.contains(
5947 permissionChecker, scopeGroupId, ActionKeys.UPDATE)) {
5948
5949 return true;
5950 }
5951 }
5952 else if (group.isUser()) {
5953 return true;
5954 }
5955 }
5956
5957 if (!portlet.isAddDefaultResource()) {
5958 return false;
5959 }
5960
5961 if (!PropsValues.PORTLET_ADD_DEFAULT_RESOURCE_CHECK_ENABLED) {
5962 return true;
5963 }
5964
5965 Set<String> whiteList =
5966 AuthTokenWhitelistUtil.getPortletInvocationWhitelist();
5967
5968 if (whiteList.contains(portletId)) {
5969 return true;
5970 }
5971
5972 String namespace = getPortletNamespace(portletId);
5973
5974 String strutsAction = ParamUtil.getString(
5975 request, namespace + "struts_action");
5976
5977 if (Validator.isNull(strutsAction)) {
5978 strutsAction = ParamUtil.getString(request, "struts_action");
5979 }
5980
5981 Set<String> whitelistActions =
5982 AuthTokenWhitelistUtil.getPortletInvocationWhitelistActions();
5983
5984 if (whitelistActions.contains(strutsAction)) {
5985 return true;
5986 }
5987
5988 String requestPortletAuthenticationToken = ParamUtil.getString(
5989 request, "p_p_auth");
5990
5991 if (Validator.isNull(requestPortletAuthenticationToken)) {
5992 HttpServletRequest originalRequest = getOriginalServletRequest(
5993 request);
5994
5995 requestPortletAuthenticationToken = ParamUtil.getString(
5996 originalRequest, "p_p_auth");
5997 }
5998
5999 if (Validator.isNotNull(requestPortletAuthenticationToken)) {
6000 String actualPortletAuthenticationToken = AuthTokenUtil.getToken(
6001 request, layout.getPlid(), portletId);
6002
6003 if (requestPortletAuthenticationToken.equals(
6004 actualPortletAuthenticationToken)) {
6005
6006 return true;
6007 }
6008 }
6009
6010 return false;
6011 }
6012
6013 @Override
6014 public boolean isCDNDynamicResourcesEnabled(HttpServletRequest request)
6015 throws PortalException, SystemException {
6016
6017 Company company = getCompany(request);
6018
6019 return isCDNDynamicResourcesEnabled(company.getCompanyId());
6020 }
6021
6022 @Override
6023 public boolean isCDNDynamicResourcesEnabled(long companyId) {
6024 try {
6025 return PrefsPropsUtil.getBoolean(
6026 companyId, PropsKeys.CDN_DYNAMIC_RESOURCES_ENABLED,
6027 PropsValues.CDN_DYNAMIC_RESOURCES_ENABLED);
6028 }
6029 catch (SystemException se) {
6030 }
6031
6032 return PropsValues.CDN_DYNAMIC_RESOURCES_ENABLED;
6033 }
6034
6035
6038 @Override
6039 public boolean isCommunityAdmin(User user, long groupId) throws Exception {
6040 return isGroupAdmin(user, groupId);
6041 }
6042
6043
6046 @Override
6047 public boolean isCommunityOwner(User user, long groupId) throws Exception {
6048 return isGroupOwner(user, groupId);
6049 }
6050
6051 @Override
6052 public boolean isCompanyAdmin(User user) throws Exception {
6053 PermissionChecker permissionChecker =
6054 PermissionCheckerFactoryUtil.create(user);
6055
6056 return permissionChecker.isCompanyAdmin();
6057 }
6058
6059 @Override
6060 public boolean isCompanyControlPanelPortlet(
6061 String portletId, String category, ThemeDisplay themeDisplay)
6062 throws PortalException, SystemException {
6063
6064 PermissionChecker permissionChecker =
6065 themeDisplay.getPermissionChecker();
6066
6067 if (permissionChecker.isCompanyAdmin()) {
6068 return true;
6069 }
6070
6071 Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
6072 themeDisplay.getCompanyId());
6073
6074 themeDisplay.setScopeGroupId(companyGroup.getGroupId());
6075
6076 return isControlPanelPortlet(portletId, category, themeDisplay);
6077 }
6078
6079 @Override
6080 public boolean isCompanyControlPanelPortlet(
6081 String portletId, ThemeDisplay themeDisplay)
6082 throws PortalException, SystemException {
6083
6084 PermissionChecker permissionChecker =
6085 themeDisplay.getPermissionChecker();
6086
6087 if (permissionChecker.isCompanyAdmin()) {
6088 return true;
6089 }
6090
6091 Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
6092 themeDisplay.getCompanyId());
6093
6094 themeDisplay.setScopeGroupId(companyGroup.getGroupId());
6095
6096 return isControlPanelPortlet(portletId, themeDisplay);
6097 }
6098
6099 @Override
6100 public boolean isCompanyControlPanelVisible(ThemeDisplay themeDisplay)
6101 throws PortalException, SystemException {
6102
6103 PermissionChecker permissionChecker =
6104 themeDisplay.getPermissionChecker();
6105
6106 if (permissionChecker.isCompanyAdmin()) {
6107 return true;
6108 }
6109
6110 long scopeGroupId = themeDisplay.getScopeGroupId();
6111
6112 try {
6113 Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
6114 themeDisplay.getCompanyId());
6115
6116 themeDisplay.setScopeGroupId(companyGroup.getGroupId());
6117
6118 List<Portlet> controlPanelPortlets = getControlPanelPortlets(
6119 PortletCategoryKeys.SITE_ADMINISTRATION, themeDisplay);
6120
6121 if (!controlPanelPortlets.isEmpty()) {
6122 return true;
6123 }
6124 else {
6125 return false;
6126 }
6127 }
6128 finally {
6129 themeDisplay.setScopeGroupId(scopeGroupId);
6130 }
6131 }
6132
6133 @Override
6134 public boolean isControlPanelPortlet(
6135 String portletId, String category, ThemeDisplay themeDisplay)
6136 throws SystemException {
6137
6138 Portlet portlet = PortletLocalServiceUtil.getPortletById(
6139 themeDisplay.getCompanyId(), portletId);
6140
6141 String controlPanelEntryCategory =
6142 portlet.getControlPanelEntryCategory();
6143
6144 if (controlPanelEntryCategory.equals(category) ||
6145 (category.endsWith(StringPool.PERIOD) &&
6146 StringUtil.startsWith(controlPanelEntryCategory, category))) {
6147
6148 return isControlPanelPortlet(portletId, themeDisplay);
6149 }
6150
6151 return false;
6152 }
6153
6154 @Override
6155 public boolean isControlPanelPortlet(
6156 String portletId, ThemeDisplay themeDisplay)
6157 throws SystemException {
6158
6159 try {
6160 return PortletPermissionUtil.hasControlPanelAccessPermission(
6161 themeDisplay.getPermissionChecker(),
6162 themeDisplay.getScopeGroupId(), portletId);
6163 }
6164 catch (PortalException pe) {
6165 if (_log.isWarnEnabled()) {
6166 _log.warn(
6167 "Unable to check control panel access permission", pe);
6168 }
6169 }
6170
6171 return false;
6172 }
6173
6174 @Override
6175 public boolean isGroupAdmin(User user, long groupId) throws Exception {
6176 PermissionChecker permissionChecker =
6177 PermissionCheckerFactoryUtil.create(user);
6178
6179 return permissionChecker.isGroupAdmin(groupId);
6180 }
6181
6182 @Override
6183 public boolean isGroupFriendlyURL(
6184 String fullURL, String groupFriendlyURL, String layoutFriendlyURL) {
6185
6186 if (fullURL.endsWith(groupFriendlyURL) &&
6187 !fullURL.endsWith(groupFriendlyURL.concat(layoutFriendlyURL))) {
6188
6189 return true;
6190 }
6191
6192 return false;
6193 }
6194
6195 @Override
6196 public boolean isGroupOwner(User user, long groupId) throws Exception {
6197 PermissionChecker permissionChecker =
6198 PermissionCheckerFactoryUtil.create(user);
6199
6200 return permissionChecker.isGroupOwner(groupId);
6201 }
6202
6203 @Override
6204 public boolean isLayoutDescendant(Layout layout, long layoutId)
6205 throws PortalException, SystemException {
6206
6207 if (layout.getLayoutId() == layoutId) {
6208 return true;
6209 }
6210
6211 for (Layout childLayout : layout.getChildren()) {
6212 if (isLayoutDescendant(childLayout, layoutId)) {
6213 return true;
6214 }
6215 }
6216
6217 return false;
6218 }
6219
6220 @Override
6221 public boolean isLayoutFirstPageable(Layout layout) {
6222 LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
6223
6224 return layoutSettings.isFirstPageable();
6225 }
6226
6227 @Override
6228 public boolean isLayoutFirstPageable(String type) {
6229 LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
6230
6231 return layoutSettings.isFirstPageable();
6232 }
6233
6234 @Override
6235 public boolean isLayoutFriendliable(Layout layout) {
6236 LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
6237
6238 return layoutSettings.isURLFriendliable();
6239 }
6240
6241 @Override
6242 public boolean isLayoutFriendliable(String type) {
6243 LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
6244
6245 return layoutSettings.isURLFriendliable();
6246 }
6247
6248 @Override
6249 public boolean isLayoutParentable(Layout layout) {
6250 return isLayoutParentable(layout.getType());
6251 }
6252
6253 @Override
6254 public boolean isLayoutParentable(String type) {
6255 LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
6256
6257 return layoutSettings.isParentable();
6258 }
6259
6260 @Override
6261 public boolean isLayoutSitemapable(Layout layout) {
6262 if (layout.isPrivateLayout()) {
6263 return false;
6264 }
6265
6266 LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
6267
6268 return layoutSettings.isSitemapable();
6269 }
6270
6271 @Override
6272 public boolean isLoginRedirectRequired(HttpServletRequest request)
6273 throws SystemException {
6274
6275 if (PropsValues.COMPANY_SECURITY_AUTH_REQUIRES_HTTPS &&
6276 !request.isSecure()) {
6277
6278 return true;
6279 }
6280
6281 long companyId = PortalUtil.getCompanyId(request);
6282
6283 if (PrefsPropsUtil.getBoolean(
6284 companyId, PropsKeys.CAS_AUTH_ENABLED,
6285 PropsValues.CAS_AUTH_ENABLED) ||
6286 PrefsPropsUtil.getBoolean(
6287 companyId, PropsKeys.LOGIN_DIALOG_DISABLED,
6288 PropsValues.LOGIN_DIALOG_DISABLED) ||
6289 PrefsPropsUtil.getBoolean(
6290 companyId, PropsKeys.NTLM_AUTH_ENABLED,
6291 PropsValues.NTLM_AUTH_ENABLED) ||
6292 PrefsPropsUtil.getBoolean(
6293 companyId, PropsKeys.OPEN_SSO_AUTH_ENABLED,
6294 PropsValues.OPEN_SSO_AUTH_ENABLED)) {
6295
6296 return true;
6297 }
6298
6299 return false;
6300 }
6301
6302 @Override
6303 public boolean isMethodGet(PortletRequest portletRequest) {
6304 HttpServletRequest request = getHttpServletRequest(portletRequest);
6305
6306 String method = GetterUtil.getString(request.getMethod());
6307
6308 if (StringUtil.equalsIgnoreCase(method, HttpMethods.GET)) {
6309 return true;
6310 }
6311 else {
6312 return false;
6313 }
6314 }
6315
6316 @Override
6317 public boolean isMethodPost(PortletRequest portletRequest) {
6318 HttpServletRequest request = getHttpServletRequest(portletRequest);
6319
6320 String method = GetterUtil.getString(request.getMethod());
6321
6322 if (StringUtil.equalsIgnoreCase(method, HttpMethods.POST)) {
6323 return true;
6324 }
6325 else {
6326 return false;
6327 }
6328 }
6329
6330 @Override
6331 public boolean isMultipartRequest(HttpServletRequest request) {
6332 String contentType = request.getHeader(HttpHeaders.CONTENT_TYPE);
6333
6334 if ((contentType != null) &&
6335 contentType.startsWith(ContentTypes.MULTIPART_FORM_DATA)) {
6336
6337 return true;
6338 }
6339 else {
6340 return false;
6341 }
6342 }
6343
6344 @Override
6345 public boolean isOmniadmin(long userId) {
6346 return OmniadminUtil.isOmniadmin(userId);
6347 }
6348
6349 @Override
6350 public boolean isReservedParameter(String name) {
6351 return _reservedParams.contains(name);
6352 }
6353
6354 @Override
6355 public boolean isRightToLeft(HttpServletRequest request) {
6356 String languageId = LanguageUtil.getLanguageId(request);
6357
6358 Locale locale = LocaleUtil.fromLanguageId(languageId);
6359
6360 String langDir = LanguageUtil.get(locale, "lang.dir");
6361
6362 return langDir.equals("rtl");
6363 }
6364
6365 @Override
6366 public boolean isRSSFeedsEnabled() {
6367 return PropsValues.RSS_FEEDS_ENABLED;
6368 }
6369
6370 @Override
6371 public boolean isSecure(HttpServletRequest request) {
6372 HttpSession session = request.getSession();
6373
6374 if (session == null) {
6375 return request.isSecure();
6376 }
6377
6378 Boolean httpsInitial = (Boolean)session.getAttribute(
6379 WebKeys.HTTPS_INITIAL);
6380
6381 boolean secure = false;
6382
6383 if (PropsValues.COMPANY_SECURITY_AUTH_REQUIRES_HTTPS &&
6384 !PropsValues.SESSION_ENABLE_PHISHING_PROTECTION &&
6385 (httpsInitial != null) && !httpsInitial.booleanValue()) {
6386
6387 secure = false;
6388 }
6389 else {
6390 secure = request.isSecure();
6391 }
6392
6393 return secure;
6394 }
6395
6396 @Override
6397 public boolean isSystemGroup(String groupName) {
6398 if (groupName == null) {
6399 return false;
6400 }
6401
6402 groupName = groupName.trim();
6403
6404 int pos = Arrays.binarySearch(
6405 _sortedSystemGroups, groupName, new StringComparator());
6406
6407 if (pos >= 0) {
6408 return true;
6409 }
6410 else {
6411 return false;
6412 }
6413 }
6414
6415 @Override
6416 public boolean isSystemRole(String roleName) {
6417 if (roleName == null) {
6418 return false;
6419 }
6420
6421 roleName = roleName.trim();
6422
6423 int pos = Arrays.binarySearch(
6424 _sortedSystemRoles, roleName, new StringComparator());
6425
6426 if (pos >= 0) {
6427 return true;
6428 }
6429
6430 pos = Arrays.binarySearch(
6431 _sortedSystemSiteRoles, roleName, new StringComparator());
6432
6433 if (pos >= 0) {
6434 return true;
6435 }
6436
6437 pos = Arrays.binarySearch(
6438 _sortedSystemOrganizationRoles, roleName, new StringComparator());
6439
6440 if (pos >= 0) {
6441 return true;
6442 }
6443
6444 return false;
6445 }
6446
6447 @Override
6448 public boolean isUpdateAvailable() throws SystemException {
6449 return PluginPackageUtil.isUpdateAvailable();
6450 }
6451
6452 @Override
6453 public boolean isValidResourceId(String resourceId) {
6454 if (Validator.isNull(resourceId)) {
6455 return true;
6456 }
6457
6458 Matcher matcher = _bannedResourceIdPattern.matcher(resourceId);
6459
6460 if (matcher.matches()) {
6461 return false;
6462 }
6463
6464 return true;
6465 }
6466
6467 @Override
6468 public void removePortalPortEventListener(
6469 PortalPortEventListener portalPortEventListener) {
6470
6471 _portalPortEventListeners.remove(portalPortEventListener);
6472 }
6473
6474 @Override
6475 public void resetCDNHosts() {
6476 _cdnHostHttpMap.clear();
6477 _cdnHostHttpsMap.clear();
6478
6479 if (!ClusterInvokeThreadLocal.isEnabled()) {
6480 return;
6481 }
6482
6483 ClusterRequest clusterRequest = ClusterRequest.createMulticastRequest(
6484 _resetCDNHostsMethodHandler, true);
6485
6486 try {
6487 ClusterExecutorUtil.execute(clusterRequest);
6488 }
6489 catch (Exception e) {
6490 _log.error("Unable to clear cluster wide CDN hosts", e);
6491 }
6492 }
6493
6494
6498 @Override
6499 public Set<String> resetPortletAddDefaultResourceCheckWhitelist() {
6500 return AuthTokenWhitelistUtil.resetPortletInvocationWhitelist();
6501 }
6502
6503
6507 @Override
6508 public Set<String> resetPortletAddDefaultResourceCheckWhitelistActions() {
6509 return AuthTokenWhitelistUtil.resetPortletInvocationWhitelistActions();
6510 }
6511
6512 @Override
6513 public String resetPortletParameters(String url, String portletId) {
6514 if (Validator.isNull(url) || Validator.isNull(portletId)) {
6515 return url;
6516 }
6517
6518 String portletNamespace = getPortletNamespace(portletId);
6519
6520 Map<String, String[]> parameterMap = HttpUtil.getParameterMap(url);
6521
6522 for (String name : parameterMap.keySet()) {
6523 if (name.startsWith(portletNamespace)) {
6524 url = HttpUtil.removeParameter(url, name);
6525 }
6526 }
6527
6528 return url;
6529 }
6530
6531 @Override
6532 public void sendError(
6533 Exception e, ActionRequest actionRequest,
6534 ActionResponse actionResponse)
6535 throws IOException {
6536
6537 sendError(0, e, actionRequest, actionResponse);
6538 }
6539
6540 @Override
6541 public void sendError(
6542 Exception e, HttpServletRequest request,
6543 HttpServletResponse response)
6544 throws IOException, ServletException {
6545
6546 sendError(0, e, request, response);
6547 }
6548
6549 @Override
6550 public void sendError(
6551 int status, Exception e, ActionRequest actionRequest,
6552 ActionResponse actionResponse)
6553 throws IOException {
6554
6555 StringBundler sb = new StringBundler(7);
6556
6557 sb.append(_pathMain);
6558 sb.append("/portal/status?status=");
6559 sb.append(status);
6560 sb.append("&exception=");
6561 sb.append(e.getClass().getName());
6562 sb.append("&previousURL=");
6563 sb.append(HttpUtil.encodeURL(getCurrentURL(actionRequest)));
6564
6565 actionResponse.sendRedirect(sb.toString());
6566 }
6567
6568 @Override
6569 public void sendError(
6570 int status, Exception e, HttpServletRequest request,
6571 HttpServletResponse response)
6572 throws IOException, ServletException {
6573
6574 if (_log.isDebugEnabled()) {
6575 String currentURL = (String)request.getAttribute(
6576 WebKeys.CURRENT_URL);
6577
6578 _log.debug(
6579 "Current URL " + currentURL + " generates exception: " +
6580 e.getMessage());
6581 }
6582
6583 if (e instanceof NoSuchImageException) {
6584 if (_logWebServerServlet.isWarnEnabled()) {
6585 _logWebServerServlet.warn(e, e);
6586 }
6587 }
6588 else if ((e instanceof PortalException) && _log.isDebugEnabled()) {
6589 if ((e instanceof NoSuchLayoutException) ||
6590 (e instanceof PrincipalException)) {
6591
6592 String msg = e.getMessage();
6593
6594 if (Validator.isNotNull(msg)) {
6595 _log.debug(msg);
6596 }
6597 }
6598 else {
6599 _log.debug(e, e);
6600 }
6601 }
6602 else if ((e instanceof SystemException) && _log.isWarnEnabled()) {
6603 _log.warn(e, e);
6604 }
6605
6606 if (response.isCommitted()) {
6607 return;
6608 }
6609
6610 if (status == 0) {
6611 if (e instanceof PrincipalException) {
6612 status = HttpServletResponse.SC_FORBIDDEN;
6613 }
6614 else {
6615 String name = e.getClass().getName();
6616
6617 name = name.substring(name.lastIndexOf(CharPool.PERIOD) + 1);
6618
6619 if (name.startsWith("NoSuch") && name.endsWith("Exception")) {
6620 status = HttpServletResponse.SC_NOT_FOUND;
6621 }
6622 }
6623
6624 if (status == 0) {
6625
6626
6627
6628 if (PropsValues.TCK_URL) {
6629 status = HttpServletResponse.SC_INTERNAL_SERVER_ERROR;
6630 }
6631 else {
6632 status = HttpServletResponse.SC_BAD_REQUEST;
6633 }
6634 }
6635 }
6636
6637 HttpSession session = PortalSessionThreadLocal.getHttpSession();
6638
6639 if (session == null) {
6640 session = request.getSession();
6641 }
6642
6643 ServletContext servletContext = session.getServletContext();
6644
6645 String redirect = PATH_MAIN + "/portal/status";
6646
6647 if ((e instanceof NoSuchGroupException) &&
6648 Validator.isNotNull(
6649 PropsValues.SITES_FRIENDLY_URL_PAGE_NOT_FOUND)) {
6650
6651 response.setStatus(status);
6652
6653 redirect = PropsValues.SITES_FRIENDLY_URL_PAGE_NOT_FOUND;
6654
6655 RequestDispatcher requestDispatcher =
6656 servletContext.getRequestDispatcher(redirect);
6657
6658 if (requestDispatcher != null) {
6659 requestDispatcher.forward(request, response);
6660 }
6661 }
6662 else if ((e instanceof NoSuchLayoutException) &&
6663 Validator.isNotNull(
6664 PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND)) {
6665
6666 response.setStatus(status);
6667
6668 redirect = PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND;
6669
6670 RequestDispatcher requestDispatcher =
6671 servletContext.getRequestDispatcher(redirect);
6672
6673 if (requestDispatcher != null) {
6674 requestDispatcher.forward(request, response);
6675 }
6676 }
6677 else if (PropsValues.LAYOUT_SHOW_HTTP_STATUS) {
6678 response.setStatus(status);
6679
6680 SessionErrors.add(session, e.getClass(), e);
6681
6682 RequestDispatcher requestDispatcher =
6683 servletContext.getRequestDispatcher(redirect);
6684
6685 if (requestDispatcher != null) {
6686 requestDispatcher.forward(request, response);
6687 }
6688 }
6689 else if (e != null) {
6690 response.sendError(status, e.getMessage());
6691 }
6692 else {
6693 String currentURL = (String)request.getAttribute(
6694 WebKeys.CURRENT_URL);
6695
6696 response.sendError(status, "Current URL " + currentURL);
6697 }
6698 }
6699
6700 @Override
6701 public void sendRSSFeedsDisabledError(
6702 HttpServletRequest request, HttpServletResponse response)
6703 throws IOException, ServletException {
6704
6705 sendError(
6706 HttpServletResponse.SC_NOT_FOUND, new NoSuchFeedException(),
6707 request, response);
6708 }
6709
6710 @Override
6711 public void sendRSSFeedsDisabledError(
6712 PortletRequest portletRequest, PortletResponse portletResponse)
6713 throws IOException, ServletException {
6714
6715 HttpServletRequest request = getHttpServletRequest(portletRequest);
6716 HttpServletResponse response = getHttpServletResponse(portletResponse);
6717
6718 sendRSSFeedsDisabledError(request, response);
6719 }
6720
6721 @Override
6722 public void setPageDescription(
6723 String description, HttpServletRequest request) {
6724
6725 ListMergeable<String> descriptionListMergeable =
6726 new ListMergeable<String>();
6727
6728 descriptionListMergeable.add(description);
6729
6730 request.setAttribute(
6731 WebKeys.PAGE_DESCRIPTION, descriptionListMergeable);
6732 }
6733
6734 @Override
6735 public void setPageKeywords(String keywords, HttpServletRequest request) {
6736 request.removeAttribute(WebKeys.PAGE_KEYWORDS);
6737
6738 addPageKeywords(keywords, request);
6739 }
6740
6741 @Override
6742 public void setPageSubtitle(String subtitle, HttpServletRequest request) {
6743 ListMergeable<String> subtitleListMergeable =
6744 new ListMergeable<String>();
6745
6746 subtitleListMergeable.add(subtitle);
6747
6748 request.setAttribute(WebKeys.PAGE_SUBTITLE, subtitleListMergeable);
6749 }
6750
6751 @Override
6752 public void setPageTitle(String title, HttpServletRequest request) {
6753 ListMergeable<String> titleListMergeable = new ListMergeable<String>();
6754
6755 titleListMergeable.add(title);
6756
6757 request.setAttribute(WebKeys.PAGE_TITLE, titleListMergeable);
6758 }
6759
6760 @Override
6761 public void setPortalPort(HttpServletRequest request) {
6762 boolean secure = request.isSecure();
6763
6764 if (secure) {
6765 if (_securePortalPort.get() == -1) {
6766 int securePortalPort = request.getServerPort();
6767
6768 if (_securePortalPort.compareAndSet(-1, securePortalPort) &&
6769 StringUtil.equalsIgnoreCase(
6770 Http.HTTPS, PropsValues.WEB_SERVER_PROTOCOL)) {
6771
6772 notifyPortalPortEventListeners(securePortalPort);
6773 notifyPortalPortProtocolEventListeners(
6774 securePortalPort, true);
6775 }
6776 }
6777 }
6778 else {
6779 if (_portalPort.get() == -1) {
6780 int portalPort = request.getServerPort();
6781
6782 if (_portalPort.compareAndSet(-1, portalPort)) {
6783 notifyPortalPortEventListeners(portalPort);
6784 notifyPortalPortProtocolEventListeners(portalPort, false);
6785 }
6786 }
6787 }
6788 }
6789
6790 @Override
6791 public void storePreferences(PortletPreferences portletPreferences)
6792 throws IOException, ValidatorException {
6793
6794 PortletPreferencesWrapper portletPreferencesWrapper =
6795 (PortletPreferencesWrapper)portletPreferences;
6796
6797 PortletPreferencesImpl portletPreferencesImpl =
6798 portletPreferencesWrapper.getPortletPreferencesImpl();
6799
6800 portletPreferencesImpl.store();
6801 }
6802
6803 @Override
6804 public String[] stripURLAnchor(String url, String separator) {
6805 String anchor = StringPool.BLANK;
6806
6807 int pos = url.indexOf(separator);
6808
6809 if (pos != -1) {
6810 anchor = url.substring(pos);
6811 url = url.substring(0, pos);
6812 }
6813
6814 return new String[] {url, anchor};
6815 }
6816
6817 @Override
6818 public String transformCustomSQL(String sql) {
6819 if ((_customSqlKeys == null) || (_customSqlValues == null)) {
6820 initCustomSQL();
6821 }
6822
6823 return StringUtil.replace(sql, _customSqlKeys, _customSqlValues);
6824 }
6825
6826 @Override
6827 public String transformSQL(String sql) {
6828 return SQLTransformer.transform(sql);
6829 }
6830
6831 @Override
6832 public PortletMode updatePortletMode(
6833 String portletId, User user, Layout layout, PortletMode portletMode,
6834 HttpServletRequest request)
6835 throws PortalException, SystemException {
6836
6837 LayoutTypePortlet layoutType =
6838 (LayoutTypePortlet)layout.getLayoutType();
6839
6840 if ((portletMode == null) || Validator.isNull(portletMode.toString())) {
6841 if (layoutType.hasModeAboutPortletId(portletId)) {
6842 return LiferayPortletMode.ABOUT;
6843 }
6844 else if (layoutType.hasModeConfigPortletId(portletId)) {
6845 return LiferayPortletMode.CONFIG;
6846 }
6847 else if (layoutType.hasModeEditPortletId(portletId)) {
6848 return PortletMode.EDIT;
6849 }
6850 else if (layoutType.hasModeEditDefaultsPortletId(portletId)) {
6851 return LiferayPortletMode.EDIT_DEFAULTS;
6852 }
6853 else if (layoutType.hasModeEditGuestPortletId(portletId)) {
6854 return LiferayPortletMode.EDIT_GUEST;
6855 }
6856 else if (layoutType.hasModeHelpPortletId(portletId)) {
6857 return PortletMode.HELP;
6858 }
6859 else if (layoutType.hasModePreviewPortletId(portletId)) {
6860 return LiferayPortletMode.PREVIEW;
6861 }
6862 else if (layoutType.hasModePrintPortletId(portletId)) {
6863 return LiferayPortletMode.PRINT;
6864 }
6865 else {
6866 return PortletMode.VIEW;
6867 }
6868 }
6869 else {
6870 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
6871 WebKeys.THEME_DISPLAY);
6872
6873 PermissionChecker permissionChecker =
6874 themeDisplay.getPermissionChecker();
6875
6876 Portlet portlet = PortletLocalServiceUtil.getPortletById(
6877 getCompanyId(request), portletId);
6878
6879 if (!PortletPermissionUtil.contains(
6880 permissionChecker, getScopeGroupId(request), layout,
6881 portlet, ActionKeys.VIEW)) {
6882
6883 return portletMode;
6884 }
6885
6886 boolean updateLayout = false;
6887
6888 if (portletMode.equals(LiferayPortletMode.ABOUT) &&
6889 !layoutType.hasModeAboutPortletId(portletId)) {
6890
6891 layoutType.addModeAboutPortletId(portletId);
6892
6893 updateLayout = true;
6894 }
6895 else if (portletMode.equals(LiferayPortletMode.CONFIG) &&
6896 !layoutType.hasModeConfigPortletId(portletId) &&
6897 PortletPermissionUtil.contains(
6898 permissionChecker, getScopeGroupId(request), layout,
6899 portlet, ActionKeys.CONFIGURATION)) {
6900
6901 layoutType.addModeConfigPortletId(portletId);
6902
6903 updateLayout = true;
6904 }
6905 else if (portletMode.equals(PortletMode.EDIT) &&
6906 !layoutType.hasModeEditPortletId(portletId) &&
6907 PortletPermissionUtil.contains(
6908 permissionChecker, getScopeGroupId(request), layout,
6909 portlet, ActionKeys.PREFERENCES)) {
6910
6911 layoutType.addModeEditPortletId(portletId);
6912
6913 updateLayout = true;
6914 }
6915 else if (portletMode.equals(LiferayPortletMode.EDIT_DEFAULTS) &&
6916 !layoutType.hasModeEditDefaultsPortletId(portletId) &&
6917 PortletPermissionUtil.contains(
6918 permissionChecker, getScopeGroupId(request), layout,
6919 portlet, ActionKeys.PREFERENCES)) {
6920
6921 layoutType.addModeEditDefaultsPortletId(portletId);
6922
6923 updateLayout = true;
6924 }
6925 else if (portletMode.equals(LiferayPortletMode.EDIT_GUEST) &&
6926 !layoutType.hasModeEditGuestPortletId(portletId) &&
6927 PortletPermissionUtil.contains(
6928 permissionChecker, getScopeGroupId(request), layout,
6929 portlet, ActionKeys.GUEST_PREFERENCES)) {
6930
6931 layoutType.addModeEditGuestPortletId(portletId);
6932
6933 updateLayout = true;
6934 }
6935 else if (portletMode.equals(PortletMode.HELP) &&
6936 !layoutType.hasModeHelpPortletId(portletId)) {
6937
6938 layoutType.addModeHelpPortletId(portletId);
6939
6940 updateLayout = true;
6941 }
6942 else if (portletMode.equals(LiferayPortletMode.PREVIEW) &&
6943 !layoutType.hasModePreviewPortletId(portletId)) {
6944
6945 layoutType.addModePreviewPortletId(portletId);
6946
6947 updateLayout = true;
6948 }
6949 else if (portletMode.equals(LiferayPortletMode.PRINT) &&
6950 !layoutType.hasModePrintPortletId(portletId)) {
6951
6952 layoutType.addModePrintPortletId(portletId);
6953
6954 updateLayout = true;
6955 }
6956 else if (portletMode.equals(PortletMode.VIEW) &&
6957 !layoutType.hasModeViewPortletId(portletId)) {
6958
6959 layoutType.removeModesPortletId(portletId);
6960
6961 updateLayout = true;
6962 }
6963
6964 if (updateLayout) {
6965 LayoutClone layoutClone = LayoutCloneFactory.getInstance();
6966
6967 if (layoutClone != null) {
6968 layoutClone.update(
6969 request, layout.getPlid(), layout.getTypeSettings());
6970 }
6971 }
6972
6973 return portletMode;
6974 }
6975 }
6976
6977 @Override
6978 public String updateRedirect(
6979 String redirect, String oldPath, String newPath) {
6980
6981 if (Validator.isNull(redirect) || (oldPath == null) ||
6982 oldPath.equals(newPath)) {
6983
6984 return redirect;
6985 }
6986
6987 String queryString = HttpUtil.getQueryString(redirect);
6988
6989 String redirectParam = HttpUtil.getParameter(
6990 redirect, "redirect", false);
6991
6992 if (Validator.isNotNull(redirectParam)) {
6993 String newRedirectParam = StringUtil.replace(
6994 redirectParam, HttpUtil.encodeURL(oldPath),
6995 HttpUtil.encodeURL(newPath));
6996
6997 queryString = StringUtil.replace(
6998 queryString, redirectParam, newRedirectParam);
6999 }
7000
7001 String redirectPath = HttpUtil.getPath(redirect);
7002
7003 int pos = redirect.indexOf(redirectPath);
7004
7005 String prefix = redirect.substring(0, pos);
7006
7007 pos = redirectPath.lastIndexOf(oldPath);
7008
7009 if (pos != -1) {
7010 prefix += redirectPath.substring(0, pos);
7011
7012 String suffix = redirectPath.substring(pos + oldPath.length());
7013
7014 redirect = prefix + newPath + suffix;
7015 }
7016 else {
7017 redirect = prefix + redirectPath;
7018 }
7019
7020 if (Validator.isNotNull(queryString)) {
7021 redirect += StringPool.QUESTION + queryString;
7022 }
7023
7024 return redirect;
7025 }
7026
7027 @Override
7028 public WindowState updateWindowState(
7029 String portletId, User user, Layout layout, WindowState windowState,
7030 HttpServletRequest request) {
7031
7032 LayoutTypePortlet layoutType =
7033 (LayoutTypePortlet)layout.getLayoutType();
7034
7035 if ((windowState == null) || Validator.isNull(windowState.toString())) {
7036 if (layoutType.hasStateMaxPortletId(portletId)) {
7037 windowState = WindowState.MAXIMIZED;
7038 }
7039 else if (layoutType.hasStateMinPortletId(portletId)) {
7040 windowState = WindowState.MINIMIZED;
7041 }
7042 else {
7043 windowState = WindowState.NORMAL;
7044 }
7045 }
7046 else {
7047 boolean updateLayout = false;
7048
7049 if (windowState.equals(WindowState.MAXIMIZED) &&
7050 !layoutType.hasStateMaxPortletId(portletId)) {
7051
7052 layoutType.addStateMaxPortletId(portletId);
7053
7054 if (PropsValues.LAYOUT_REMEMBER_MAXIMIZED_WINDOW_STATE) {
7055 updateLayout = true;
7056 }
7057 }
7058 else if (windowState.equals(WindowState.MINIMIZED) &&
7059 !layoutType.hasStateMinPortletId(portletId)) {
7060
7061 layoutType.addStateMinPortletId(portletId);
7062
7063 updateLayout = true;
7064 }
7065 else if (windowState.equals(WindowState.NORMAL) &&
7066 !layoutType.hasStateNormalPortletId(portletId)) {
7067
7068 layoutType.removeStatesPortletId(portletId);
7069
7070 updateLayout = true;
7071 }
7072
7073 if (portletId.equals(PortletKeys.LAYOUTS_ADMIN) ||
7074 portletId.equals(PortletKeys.PORTLET_CONFIGURATION)) {
7075
7076 updateLayout = false;
7077 }
7078
7079 if (updateLayout) {
7080 LayoutClone layoutClone = LayoutCloneFactory.getInstance();
7081
7082 if (layoutClone != null) {
7083 layoutClone.update(
7084 request, layout.getPlid(), layout.getTypeSettings());
7085 }
7086 }
7087 }
7088
7089 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
7090 WebKeys.THEME_DISPLAY);
7091
7092 themeDisplay.setStateExclusive(
7093 windowState.equals(LiferayWindowState.EXCLUSIVE));
7094 themeDisplay.setStateMaximized(
7095 windowState.equals(WindowState.MAXIMIZED));
7096 themeDisplay.setStatePopUp(
7097 windowState.equals(LiferayWindowState.POP_UP));
7098
7099 if (themeDisplay.isStateMaximized() &&
7100 themeDisplay.isShowAddContentIcon()) {
7101
7102 themeDisplay.setShowAddContentIcon(false);
7103 }
7104 else if (!themeDisplay.isStateMaximized() &&
7105 !themeDisplay.isShowAddContentIcon() &&
7106 themeDisplay.isShowAddContentIconPermission()) {
7107
7108 themeDisplay.setShowAddContentIcon(true);
7109 }
7110
7111 request.setAttribute(WebKeys.WINDOW_STATE, windowState);
7112
7113 return windowState;
7114 }
7115
7116 protected void addDefaultResource(
7117 long companyId, Layout layout, Portlet portlet,
7118 boolean portletActions)
7119 throws PortalException, SystemException {
7120
7121 long groupId = getScopeGroupId(layout, portlet.getPortletId());
7122
7123 addDefaultResource(companyId, groupId, layout, portlet, portletActions);
7124 }
7125
7126 protected void addDefaultResource(
7127 long companyId, long groupId, Layout layout, Portlet portlet,
7128 boolean portletActions)
7129 throws PortalException, SystemException {
7130
7131 String rootPortletId = portlet.getRootPortletId();
7132
7133 String portletPrimaryKey = PortletPermissionUtil.getPrimaryKey(
7134 layout.getPlid(), portlet.getPortletId());
7135
7136 String name = null;
7137 String primaryKey = null;
7138
7139 if (portletActions) {
7140 name = rootPortletId;
7141 primaryKey = portletPrimaryKey;
7142 }
7143 else {
7144 Group group = GroupLocalServiceUtil.fetchGroup(groupId);
7145
7146 if ((group != null) && group.isStagingGroup()) {
7147 groupId = group.getLiveGroupId();
7148 }
7149
7150 name = ResourceActionsUtil.getPortletBaseResource(rootPortletId);
7151 primaryKey = String.valueOf(groupId);
7152 }
7153
7154 if (Validator.isNull(name)) {
7155 return;
7156 }
7157
7158 int count =
7159 ResourcePermissionLocalServiceUtil.getResourcePermissionsCount(
7160 companyId, name, ResourceConstants.SCOPE_INDIVIDUAL,
7161 primaryKey);
7162
7163 if (count > 0) {
7164 return;
7165 }
7166
7167 boolean addGuestPermissions = true;
7168
7169 if (portletActions) {
7170 Group layoutGroup = layout.getGroup();
7171
7172 if (layout.isPrivateLayout() && !layoutGroup.isLayoutPrototype() &&
7173 !layoutGroup.isLayoutSetPrototype()) {
7174
7175 addGuestPermissions = false;
7176 }
7177 }
7178
7179 ResourceLocalServiceUtil.addResources(
7180 companyId, groupId, 0, name, primaryKey, portletActions, true,
7181 addGuestPermissions);
7182 }
7183
7184 protected String buildI18NPath(Locale locale) {
7185 String languageId = LocaleUtil.toLanguageId(locale);
7186
7187 if (Validator.isNull(languageId)) {
7188 return null;
7189 }
7190
7191 if (LanguageUtil.isDuplicateLanguageCode(locale.getLanguage())) {
7192 Locale priorityLocale = LanguageUtil.getLocale(
7193 locale.getLanguage());
7194
7195 if (locale.equals(priorityLocale)) {
7196 languageId = locale.getLanguage();
7197 }
7198 }
7199 else {
7200 languageId = locale.getLanguage();
7201 }
7202
7203 return StringPool.SLASH.concat(languageId);
7204 }
7205
7206 protected List<Group> doGetAncestorSiteGroups(
7207 long groupId, boolean checkContentSharingWithChildrenEnabled)
7208 throws PortalException, SystemException {
7209
7210 List<Group> groups = new UniqueList<Group>();
7211
7212 long siteGroupId = getSiteGroupId(groupId);
7213
7214 Group siteGroup = GroupLocalServiceUtil.getGroup(siteGroupId);
7215
7216 for (Group group : siteGroup.getAncestors()) {
7217 if (checkContentSharingWithChildrenEnabled &&
7218 !SitesUtil.isContentSharingWithChildrenEnabled(group)) {
7219
7220 continue;
7221 }
7222
7223 groups.add(group);
7224 }
7225
7226 if (!siteGroup.isCompany()) {
7227 groups.add(
7228 GroupLocalServiceUtil.getCompanyGroup(
7229 siteGroup.getCompanyId()));
7230 }
7231
7232 return groups;
7233 }
7234
7235 protected Group doGetCurrentSiteGroup(long groupId)
7236 throws PortalException, SystemException {
7237
7238 long siteGroupId = getSiteGroupId(groupId);
7239
7240 Group siteGroup = GroupLocalServiceUtil.getGroup(siteGroupId);
7241
7242 if (!siteGroup.isLayoutPrototype()) {
7243 return siteGroup;
7244 }
7245
7246 return null;
7247 }
7248
7249 protected long doGetPlidFromPortletId(
7250 long groupId, boolean privateLayout, String portletId)
7251 throws PortalException, SystemException {
7252
7253 long scopeGroupId = groupId;
7254
7255 try {
7256 Group group = GroupLocalServiceUtil.getGroup(groupId);
7257
7258 if (group.isLayout()) {
7259 Layout scopeLayout = LayoutLocalServiceUtil.getLayout(
7260 group.getClassPK());
7261
7262 groupId = scopeLayout.getGroupId();
7263 }
7264 }
7265 catch (Exception e) {
7266 }
7267
7268 long plid = LayoutConstants.DEFAULT_PLID;
7269
7270 List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
7271 groupId, privateLayout, LayoutConstants.TYPE_PORTLET);
7272
7273 for (Layout layout : layouts) {
7274 LayoutTypePortlet layoutTypePortlet =
7275 (LayoutTypePortlet)layout.getLayoutType();
7276
7277 if (layoutTypePortlet.hasPortletId(portletId, true)) {
7278 if (getScopeGroupId(layout, portletId) == scopeGroupId) {
7279 plid = layout.getPlid();
7280
7281 break;
7282 }
7283 }
7284 }
7285
7286 return plid;
7287 }
7288
7289 protected List<Portlet> filterControlPanelPortlets(
7290 Set<Portlet> portlets, ThemeDisplay themeDisplay) {
7291
7292 List<Portlet> filteredPortlets = new ArrayList<Portlet>(portlets);
7293
7294 Iterator<Portlet> itr = filteredPortlets.iterator();
7295
7296 while (itr.hasNext()) {
7297 Portlet portlet = itr.next();
7298
7299 try {
7300 if (!portlet.isActive() || portlet.isInstanceable() ||
7301 !PortletPermissionUtil.hasControlPanelAccessPermission(
7302 themeDisplay.getPermissionChecker(),
7303 themeDisplay.getScopeGroupId(), portlet)) {
7304
7305 itr.remove();
7306 }
7307 }
7308 catch (Exception e) {
7309 _log.error(e, e);
7310
7311 itr.remove();
7312 }
7313 }
7314
7315 return filteredPortlets;
7316 }
7317
7318 protected Locale getAvailableLocale(long groupId, Locale locale) {
7319 if (Validator.isNull(locale.getCountry())) {
7320
7321
7322
7323 locale = LanguageUtil.getLocale(locale.getLanguage());
7324 }
7325
7326 if (!LanguageUtil.isAvailableLocale(groupId, locale)) {
7327 return null;
7328 }
7329
7330 return locale;
7331 }
7332
7333 protected String getCanonicalDomain(
7334 String virtualHostname, String portalDomain) {
7335
7336 if (Validator.isBlank(portalDomain) ||
7337 StringUtil.equalsIgnoreCase(portalDomain, _LOCALHOST) ||
7338 !StringUtil.equalsIgnoreCase(virtualHostname, _LOCALHOST)) {
7339
7340 return virtualHostname;
7341 }
7342
7343 int pos = portalDomain.indexOf(CharPool.COLON);
7344
7345 if (pos == -1) {
7346 return portalDomain;
7347 }
7348
7349 return portalDomain.substring(0, pos);
7350 }
7351
7352 protected Map<String, List<Portlet>> getCategoriesMap(
7353 HttpServletRequest request, String attributeName,
7354 String[] categories)
7355 throws SystemException {
7356
7357 Map<String, List<Portlet>> categoriesMap =
7358 (Map<String, List<Portlet>>)request.getAttribute(attributeName);
7359
7360 if (categoriesMap != null) {
7361 return categoriesMap;
7362 }
7363
7364 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
7365 WebKeys.THEME_DISPLAY);
7366
7367 categoriesMap = new LinkedHashMap<String, List<Portlet>>();
7368
7369 for (String category : categories) {
7370 List<Portlet> portlets = getControlPanelPortlets(
7371 category, themeDisplay);
7372
7373 if (!portlets.isEmpty()) {
7374 categoriesMap.put(category, portlets);
7375 }
7376 }
7377
7378 request.setAttribute(attributeName, categoriesMap);
7379
7380 return categoriesMap;
7381 }
7382
7383 protected long getDefaultScopeGroupId(long companyId)
7384 throws PortalException, SystemException {
7385
7386 long doAsGroupId = 0;
7387
7388 Collection<Portlet> portlets = getControlPanelPortlets(
7389 companyId, PortletCategoryKeys.SITE_ADMINISTRATION);
7390
7391 List<Group> groups = GroupServiceUtil.getManageableSiteGroups(
7392 portlets, 1);
7393
7394 if (!groups.isEmpty()) {
7395 Group group = groups.get(0);
7396
7397 doAsGroupId = group.getGroupId();
7398 }
7399 else {
7400 Group guestGroup = GroupLocalServiceUtil.fetchGroup(
7401 companyId, GroupConstants.GUEST);
7402
7403 if (guestGroup != null) {
7404 doAsGroupId = guestGroup.getGroupId();
7405 }
7406 }
7407
7408 return doAsGroupId;
7409 }
7410
7411 protected long getDoAsUserId(
7412 HttpServletRequest request, String doAsUserIdString,
7413 boolean alwaysAllowDoAsUser)
7414 throws Exception {
7415
7416 if (Validator.isNull(doAsUserIdString)) {
7417 return 0;
7418 }
7419
7420 long doAsUserId = 0;
7421
7422 try {
7423 Company company = getCompany(request);
7424
7425 doAsUserId = GetterUtil.getLong(
7426 Encryptor.decrypt(company.getKeyObj(), doAsUserIdString));
7427 }
7428 catch (Exception e) {
7429 if (_log.isWarnEnabled()) {
7430 _log.warn(
7431 "Unable to impersonate " + doAsUserIdString +
7432 " because the string cannot be decrypted");
7433 }
7434
7435 return 0;
7436 }
7437
7438 if (_log.isDebugEnabled()) {
7439 if (alwaysAllowDoAsUser) {
7440 _log.debug(
7441 "doAsUserId path or Struts action is always allowed");
7442 }
7443 else {
7444 _log.debug(
7445 "doAsUserId path is Struts action not always allowed");
7446 }
7447 }
7448
7449 if (alwaysAllowDoAsUser) {
7450 request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
7451
7452 return doAsUserId;
7453 }
7454
7455 HttpSession session = request.getSession();
7456
7457 Long realUserIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
7458
7459 if (realUserIdObj == null) {
7460 return 0;
7461 }
7462
7463 User doAsUser = UserLocalServiceUtil.getUserById(doAsUserId);
7464
7465 long[] organizationIds = doAsUser.getOrganizationIds();
7466
7467 User realUser = UserLocalServiceUtil.getUserById(
7468 realUserIdObj.longValue());
7469
7470 PermissionChecker permissionChecker =
7471 PermissionCheckerFactoryUtil.create(realUser);
7472
7473 if (doAsUser.isDefaultUser() ||
7474 UserPermissionUtil.contains(
7475 permissionChecker, doAsUserId, organizationIds,
7476 ActionKeys.IMPERSONATE)) {
7477
7478 request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
7479
7480 return doAsUserId;
7481 }
7482
7483 _log.error(
7484 "User " + realUserIdObj + " does not have the permission to " +
7485 "impersonate " + doAsUserId);
7486
7487 return 0;
7488 }
7489
7490 protected String getGroupFriendlyURL(
7491 LayoutSet layoutSet, ThemeDisplay themeDisplay,
7492 boolean canonicalURL)
7493 throws PortalException, SystemException {
7494
7495 Group group = layoutSet.getGroup();
7496
7497 boolean privateLayoutSet = layoutSet.getPrivateLayout();
7498
7499 String portalURL = themeDisplay.getPortalURL();
7500
7501 boolean useGroupVirtualHostName = false;
7502
7503 if (canonicalURL ||
7504 !StringUtil.equalsIgnoreCase(
7505 themeDisplay.getServerName(), _LOCALHOST)) {
7506
7507 useGroupVirtualHostName = true;
7508 }
7509
7510 long refererPlid = themeDisplay.getRefererPlid();
7511
7512 if (refererPlid > 0) {
7513 Layout refererLayout = LayoutLocalServiceUtil.fetchLayout(
7514 refererPlid);
7515
7516 if ((refererLayout != null) &&
7517 ((refererLayout.getGroupId() != group.getGroupId()) ||
7518 (refererLayout.isPrivateLayout() != privateLayoutSet))) {
7519
7520 useGroupVirtualHostName = false;
7521 }
7522 }
7523
7524 if (useGroupVirtualHostName) {
7525 String virtualHostname = getVirtualHostname(layoutSet);
7526
7527 String portalDomain = HttpUtil.getDomain(portalURL);
7528
7529 if (Validator.isNotNull(virtualHostname) &&
7530 (canonicalURL ||
7531 !StringUtil.equalsIgnoreCase(virtualHostname, _LOCALHOST))) {
7532
7533 virtualHostname = getCanonicalDomain(
7534 virtualHostname, portalDomain);
7535
7536 virtualHostname = getPortalURL(
7537 virtualHostname, themeDisplay.getServerPort(),
7538 themeDisplay.isSecure());
7539
7540 if (canonicalURL || virtualHostname.contains(portalDomain)) {
7541 String path = StringPool.BLANK;
7542
7543 if (themeDisplay.isWidget()) {
7544 path = PropsValues.WIDGET_SERVLET_MAPPING;
7545 }
7546
7547 if (themeDisplay.isI18n() && !canonicalURL) {
7548 path = themeDisplay.getI18nPath();
7549 }
7550
7551 return virtualHostname.concat(_pathContext).concat(path);
7552 }
7553 }
7554 else {
7555 LayoutSet curLayoutSet = LayoutSetLocalServiceUtil.getLayoutSet(
7556 themeDisplay.getSiteGroupId(), privateLayoutSet);
7557
7558 if (canonicalURL ||
7559 ((layoutSet.getLayoutSetId() !=
7560 curLayoutSet.getLayoutSetId()) &&
7561 (group.getClassPK() != themeDisplay.getUserId()))) {
7562
7563 if (group.isControlPanel()) {
7564 virtualHostname = themeDisplay.getServerName();
7565
7566 if (Validator.isNull(virtualHostname) ||
7567 StringUtil.equalsIgnoreCase(
7568 virtualHostname, _LOCALHOST)) {
7569
7570 virtualHostname = curLayoutSet.getVirtualHostname();
7571 }
7572 }
7573
7574 if (Validator.isNull(virtualHostname) ||
7575 StringUtil.equalsIgnoreCase(
7576 virtualHostname, _LOCALHOST)) {
7577
7578 Company company = themeDisplay.getCompany();
7579
7580 virtualHostname = company.getVirtualHostname();
7581 }
7582
7583 if (canonicalURL ||
7584 !StringUtil.equalsIgnoreCase(
7585 virtualHostname, _LOCALHOST)) {
7586
7587 virtualHostname = getCanonicalDomain(
7588 virtualHostname, portalDomain);
7589
7590 portalURL = getPortalURL(
7591 virtualHostname, themeDisplay.getServerPort(),
7592 themeDisplay.isSecure());
7593 }
7594 }
7595 }
7596 }
7597
7598 String friendlyURL = null;
7599
7600 if (privateLayoutSet) {
7601 if (group.isUser()) {
7602 friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
7603 }
7604 else {
7605 friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
7606 }
7607 }
7608 else {
7609 friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
7610 }
7611
7612 StringBundler sb = new StringBundler(6);
7613
7614 sb.append(portalURL);
7615 sb.append(_pathContext);
7616
7617 if (themeDisplay.isI18n() && !canonicalURL) {
7618 sb.append(themeDisplay.getI18nPath());
7619 }
7620
7621 if (themeDisplay.isWidget()) {
7622 sb.append(PropsValues.WIDGET_SERVLET_MAPPING);
7623 }
7624
7625 sb.append(friendlyURL);
7626 sb.append(group.getFriendlyURL());
7627
7628 return sb.toString();
7629 }
7630
7631 protected String getPortletParam(HttpServletRequest request, String name) {
7632 String portletId = ParamUtil.getString(request, "p_p_id");
7633
7634 if (Validator.isNull(portletId)) {
7635 return StringPool.BLANK;
7636 }
7637
7638 String value = null;
7639
7640 int valueCount = 0;
7641
7642 String keyName = StringPool.UNDERLINE.concat(name);
7643
7644 Map<String, String[]> parameterMap = request.getParameterMap();
7645
7646 for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
7647 String parameterName = entry.getKey();
7648
7649 int pos = parameterName.indexOf(keyName);
7650
7651 if (pos == -1) {
7652 continue;
7653 }
7654
7655 valueCount++;
7656
7657
7658
7659 if (valueCount > 1) {
7660 return StringPool.BLANK;
7661 }
7662
7663 String[] parameterValues = entry.getValue();
7664
7665 if (ArrayUtil.isEmpty(parameterValues) ||
7666 Validator.isNull(parameterValues[0])) {
7667
7668 continue;
7669 }
7670
7671
7672
7673 String portletId1 = parameterName.substring(1, pos);
7674
7675 if (portletId.equals(portletId1)) {
7676 value = parameterValues[0];
7677 }
7678 }
7679
7680 if (value == null) {
7681 value = StringPool.BLANK;
7682 }
7683
7684 return value;
7685 }
7686
7687 protected String getServletURL(
7688 Portlet portlet, String servletPath, ThemeDisplay themeDisplay)
7689 throws PortalException, SystemException {
7690
7691 Layout layout = themeDisplay.getLayout();
7692
7693 StringBundler sb = new StringBundler();
7694
7695 sb.append(themeDisplay.getPortalURL());
7696
7697 if (Validator.isNotNull(_pathContext)) {
7698 sb.append(_pathContext);
7699 }
7700
7701 if (themeDisplay.isI18n()) {
7702 sb.append(themeDisplay.getI18nPath());
7703 }
7704
7705 sb.append(servletPath);
7706
7707 Group group = layout.getGroup();
7708
7709 if (layout.isPrivateLayout()) {
7710 if (group.isUser()) {
7711 sb.append(_PRIVATE_USER_SERVLET_MAPPING);
7712 }
7713 else {
7714 sb.append(_PRIVATE_GROUP_SERVLET_MAPPING);
7715 }
7716 }
7717 else {
7718 sb.append(_PUBLIC_GROUP_SERVLET_MAPPING);
7719 }
7720
7721 sb.append(group.getFriendlyURL());
7722 sb.append(layout.getFriendlyURL(themeDisplay.getLocale()));
7723
7724 sb.append(FRIENDLY_URL_SEPARATOR);
7725
7726 FriendlyURLMapper friendlyURLMapper =
7727 portlet.getFriendlyURLMapperInstance();
7728
7729 if ((friendlyURLMapper != null) && !portlet.isInstanceable()) {
7730 sb.append(friendlyURLMapper.getMapping());
7731 }
7732 else {
7733 sb.append(portlet.getPortletId());
7734 }
7735
7736 return sb.toString();
7737 }
7738
7739 public String getVirtualHostname(LayoutSet layoutSet) {
7740 String virtualHostname = layoutSet.getVirtualHostname();
7741
7742 if (Validator.isNull(virtualHostname)) {
7743 virtualHostname = layoutSet.getCompanyFallbackVirtualHostname();
7744 }
7745
7746 return virtualHostname;
7747 }
7748
7749 protected boolean isAlwaysAllowDoAsUser(HttpServletRequest request)
7750 throws Exception {
7751
7752 String ticketKey = ParamUtil.getString(request, "ticketKey");
7753
7754 if (Validator.isNull(ticketKey)) {
7755 return false;
7756 }
7757
7758 Ticket ticket = TicketLocalServiceUtil.fetchTicket(ticketKey);
7759
7760 if ((ticket == null) ||
7761 (ticket.getType() != TicketConstants.TYPE_IMPERSONATE)) {
7762
7763 return false;
7764 }
7765
7766 String className = ticket.getClassName();
7767
7768 if (!className.equals(User.class.getName())) {
7769 return false;
7770 }
7771
7772 long doAsUserId = 0;
7773
7774 try {
7775 Company company = getCompany(request);
7776
7777 String doAsUserIdString = ParamUtil.getString(
7778 request, "doAsUserId");
7779
7780 if (Validator.isNotNull(doAsUserIdString)) {
7781 doAsUserId = GetterUtil.getLong(
7782 Encryptor.decrypt(company.getKeyObj(), doAsUserIdString));
7783 }
7784 }
7785 catch (Exception e) {
7786 return false;
7787 }
7788
7789 if (ticket.getClassPK() != doAsUserId) {
7790 return false;
7791 }
7792
7793 if (ticket.isExpired()) {
7794 TicketLocalServiceUtil.deleteTicket(ticket);
7795
7796 return false;
7797 }
7798
7799 Date expirationDate = new Date(
7800 System.currentTimeMillis() +
7801 PropsValues.SESSION_TIMEOUT * Time.MINUTE);
7802
7803 ticket.setExpirationDate(expirationDate);
7804
7805 TicketLocalServiceUtil.updateTicket(ticket);
7806
7807 return true;
7808 }
7809
7810
7813 protected boolean isPanelSelectedPortlet(
7814 ThemeDisplay themeDisplay, String portletId) {
7815
7816 Layout layout = themeDisplay.getLayout();
7817
7818 String panelSelectedPortlets = layout.getTypeSettingsProperty(
7819 "panelSelectedPortlets");
7820
7821 if (Validator.isNotNull(panelSelectedPortlets)) {
7822 String[] panelSelectedPortletsArray = StringUtil.split(
7823 panelSelectedPortlets);
7824
7825 return ArrayUtil.contains(panelSelectedPortletsArray, portletId);
7826 }
7827
7828 return false;
7829 }
7830
7831 protected boolean isValidPortalDomain(long companyId, String domain) {
7832 if (_validPortalDomainCheckDisabled) {
7833 return true;
7834 }
7835
7836 if (!Validator.isHostName(domain)) {
7837 return false;
7838 }
7839
7840 for (String virtualHost : PropsValues.VIRTUAL_HOSTS_VALID_HOSTS) {
7841 if (StringUtil.equalsIgnoreCase(domain, virtualHost) ||
7842 StringUtil.wildcardMatches(
7843 domain, virtualHost, CharPool.QUESTION, CharPool.STAR,
7844 CharPool.PERCENT, false)) {
7845
7846 return true;
7847 }
7848 }
7849
7850 if (StringUtil.equalsIgnoreCase(domain, PropsValues.WEB_SERVER_HOST)) {
7851 return true;
7852 }
7853
7854 if (isValidVirtualHostname(domain)) {
7855 return true;
7856 }
7857
7858 if (StringUtil.equalsIgnoreCase(domain, getCDNHostHttp(companyId))) {
7859 return true;
7860 }
7861
7862 if (StringUtil.equalsIgnoreCase(domain, getCDNHostHttps(companyId))) {
7863 return true;
7864 }
7865
7866 return false;
7867 }
7868
7869 protected boolean isValidPortalDomain(String domain) {
7870 long companyId = CompanyThreadLocal.getCompanyId();
7871
7872 return isValidPortalDomain(companyId, domain);
7873 }
7874
7875 protected boolean isValidVirtualHostname(String virtualHostname) {
7876 try {
7877 virtualHostname = StringUtil.toLowerCase(virtualHostname.trim());
7878
7879 VirtualHost virtualHost =
7880 VirtualHostLocalServiceUtil.fetchVirtualHost(virtualHostname);
7881
7882 if (virtualHost != null) {
7883 return true;
7884 }
7885 }
7886 catch (Exception e) {
7887 }
7888
7889 return false;
7890 }
7891
7892 protected void notifyPortalPortEventListeners(int portalPort) {
7893 for (PortalPortEventListener portalPortEventListener :
7894 _portalPortEventListeners) {
7895
7896 portalPortEventListener.portalPortConfigured(portalPort);
7897 }
7898 }
7899
7900 protected void notifyPortalPortProtocolEventListeners(
7901 int portalPort, Boolean secure) {
7902
7903 for (PortalPortProtocolEventListener portalPortProtocolEventListener :
7904 _portalPortProtocolEventListeners) {
7905
7906 portalPortProtocolEventListener.portalPortProtocolConfigured(
7907 portalPort, secure);
7908 }
7909 }
7910
7911 protected String removeRedirectParameter(String url) {
7912 String queryString = HttpUtil.getQueryString(url);
7913
7914 Map<String, String[]> parameterMap = HttpUtil.getParameterMap(
7915 queryString);
7916
7917 for (String parameter : parameterMap.keySet()) {
7918 if (parameter.endsWith("redirect")) {
7919 url = HttpUtil.removeParameter(url, parameter);
7920 }
7921 }
7922
7923 return url;
7924 }
7925
7926 protected void resetThemeDisplayI18n(
7927 ThemeDisplay themeDisplay, String languageId, String path,
7928 Locale locale) {
7929
7930 themeDisplay.setI18nLanguageId(languageId);
7931 themeDisplay.setI18nPath(path);
7932 themeDisplay.setLocale(locale);
7933 }
7934
7935 protected void setLocale(
7936 HttpServletRequest request, HttpServletResponse response,
7937 Locale locale) {
7938
7939 HttpSession session = request.getSession();
7940
7941 session.setAttribute(Globals.LOCALE_KEY, locale);
7942
7943 LanguageUtil.updateCookie(request, response, locale);
7944 }
7945
7946 protected void setThemeDisplayI18n(
7947 ThemeDisplay themeDisplay, Locale locale) {
7948
7949 String i18nLanguageId = null;
7950 String i18nPath = null;
7951
7952 if ((I18nFilter.getLanguageIds().contains(locale.toString()) &&
7953 ((PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 1) &&
7954 !locale.equals(LocaleUtil.getDefault()))) ||
7955 (PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 2)) {
7956
7957 i18nLanguageId = locale.toString();
7958 i18nPath = buildI18NPath(locale);
7959 }
7960
7961 themeDisplay.setI18nLanguageId(i18nLanguageId);
7962 themeDisplay.setI18nPath(i18nPath);
7963 themeDisplay.setLocale(locale);
7964 }
7965
7966 private static final String _J_SECURITY_CHECK = "j_security_check";
7967
7968 private static final String _LOCALHOST = "localhost";
7969
7970 private static final String _PRIVATE_GROUP_SERVLET_MAPPING =
7971 PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_GROUP_SERVLET_MAPPING;
7972
7973 private static final String _PRIVATE_USER_SERVLET_MAPPING =
7974 PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_USER_SERVLET_MAPPING;
7975
7976 private static final String _PUBLIC_GROUP_SERVLET_MAPPING =
7977 PropsValues.LAYOUT_FRIENDLY_URL_PUBLIC_SERVLET_MAPPING;
7978
7979 private static Log _log = LogFactoryUtil.getLog(PortalImpl.class);
7980
7981 private static Log _logWebServerServlet = LogFactoryUtil.getLog(
7982 WebServerServlet.class);
7983
7984 private static Map<Long, String> _cdnHostHttpMap =
7985 new ConcurrentHashMap<Long, String>();
7986 private static Map<Long, String> _cdnHostHttpsMap =
7987 new ConcurrentHashMap<Long, String>();
7988 private static MethodHandler _resetCDNHostsMethodHandler =
7989 new MethodHandler(new MethodKey(PortalUtil.class, "resetCDNHosts"));
7990 private static Date _upTime = new Date();
7991
7992 private String[] _allSystemGroups;
7993 private String[] _allSystemOrganizationRoles;
7994 private String[] _allSystemRoles;
7995 private String[] _allSystemSiteRoles;
7996 private Pattern _bannedResourceIdPattern = Pattern.compile(
7997 PropsValues.PORTLET_RESOURCE_ID_BANNED_PATHS_REGEXP,
7998 Pattern.CASE_INSENSITIVE);
7999 private String _computerAddress;
8000 private String _computerName;
8001 private String[] _customSqlKeys;
8002 private String[] _customSqlValues;
8003 private EditDiscussionAction _editDiscussionAction =
8004 new EditDiscussionAction();
8005 private String _pathContext;
8006 private String _pathFriendlyURLPrivateGroup;
8007 private String _pathFriendlyURLPrivateUser;
8008 private String _pathFriendlyURLPublic;
8009 private String _pathImage;
8010 private String _pathMain;
8011 private String _pathModule;
8012 private String _pathProxy;
8013 private Map<String, Long> _plidToPortletIdMap =
8014 new ConcurrentHashMap<String, Long>();
8015 private final AtomicInteger _portalPort = new AtomicInteger(-1);
8016 private List<PortalPortEventListener> _portalPortEventListeners =
8017 new ArrayList<PortalPortEventListener>();
8018 private List<PortalPortProtocolEventListener>
8019 _portalPortProtocolEventListeners =
8020 new ArrayList<PortalPortProtocolEventListener>();
8021 private Set<String> _reservedParams;
8022 private final AtomicInteger _securePortalPort = new AtomicInteger(-1);
8023 private final String _servletContextName;
8024 private String[] _sortedSystemGroups;
8025 private String[] _sortedSystemOrganizationRoles;
8026 private String[] _sortedSystemRoles;
8027 private String[] _sortedSystemSiteRoles;
8028 private boolean _validPortalDomainCheckDisabled;
8029
8030 }