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