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