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