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 List<PersistentHttpServletRequestWrapper>
5109 persistentHttpServletRequestWrappers =
5110 new ArrayList<PersistentHttpServletRequestWrapper>();
5111
5112 HttpServletRequest currentRequest = request;
5113
5114 while (currentRequest instanceof HttpServletRequestWrapper) {
5115 if (currentRequest instanceof UploadServletRequest) {
5116 return (UploadServletRequest)currentRequest;
5117 }
5118
5119 if (currentRequest instanceof
5120 PersistentHttpServletRequestWrapper) {
5121
5122 PersistentHttpServletRequestWrapper
5123 persistentHttpServletRequestWrapper =
5124 (PersistentHttpServletRequestWrapper)currentRequest;
5125
5126 persistentHttpServletRequestWrappers.add(
5127 persistentHttpServletRequestWrapper.clone());
5128 }
5129
5130 HttpServletRequestWrapper httpServletRequestWrapper =
5131 (HttpServletRequestWrapper)currentRequest;
5132
5133 currentRequest =
5134 (HttpServletRequest)httpServletRequestWrapper.getRequest();
5135 }
5136
5137 if (ServerDetector.isWebLogic()) {
5138 currentRequest = new NonSerializableObjectRequestWrapper(
5139 currentRequest);
5140 }
5141
5142 for (int i = persistentHttpServletRequestWrappers.size() - 1; i >= 0;
5143 i--) {
5144
5145 HttpServletRequestWrapper httpServletRequestWrapper =
5146 persistentHttpServletRequestWrappers.get(i);
5147
5148 httpServletRequestWrapper.setRequest(currentRequest);
5149
5150 currentRequest = httpServletRequestWrapper;
5151 }
5152
5153 return new UploadServletRequestImpl(currentRequest);
5154 }
5155
5156 @Override
5157 public Date getUptime() {
5158 return _upTime;
5159 }
5160
5161 @Override
5162 public String getURLWithSessionId(String url, String sessionId) {
5163 if (!PropsValues.SESSION_ENABLE_URL_WITH_SESSION_ID) {
5164 return url;
5165 }
5166
5167 if (Validator.isNull(url)) {
5168 return url;
5169 }
5170
5171
5172
5173 int x = url.indexOf(CharPool.SEMICOLON);
5174
5175 if (x != -1) {
5176 return url;
5177 }
5178
5179 x = url.indexOf(CharPool.QUESTION);
5180
5181 if (x != -1) {
5182 StringBundler sb = new StringBundler(4);
5183
5184 sb.append(url.substring(0, x));
5185 sb.append(_JSESSIONID);
5186 sb.append(sessionId);
5187 sb.append(url.substring(x));
5188
5189 return sb.toString();
5190 }
5191
5192
5193
5194
5195 x = url.indexOf(StringPool.DOUBLE_SLASH);
5196
5197 StringBundler sb = new StringBundler(4);
5198
5199 sb.append(url);
5200
5201 if (x != -1) {
5202 int y = url.lastIndexOf(CharPool.SLASH);
5203
5204 if ((x + 1) == y) {
5205 sb.append(StringPool.SLASH);
5206 }
5207 }
5208
5209 sb.append(_JSESSIONID);
5210 sb.append(sessionId);
5211
5212 return sb.toString();
5213 }
5214
5215 @Override
5216 public User getUser(HttpServletRequest request)
5217 throws PortalException, SystemException {
5218
5219 User user = (User)request.getAttribute(WebKeys.USER);
5220
5221 if (user != null) {
5222 return user;
5223 }
5224
5225 long userId = getUserId(request);
5226
5227 if (userId <= 0) {
5228
5229
5230
5231
5232
5233
5234 String remoteUser = request.getRemoteUser();
5235
5236 if (remoteUser == null) {
5237 return null;
5238 }
5239
5240 userId = GetterUtil.getLong(remoteUser);
5241 }
5242
5243 if (userId > 0) {
5244 user = UserLocalServiceUtil.getUserById(userId);
5245
5246 request.setAttribute(WebKeys.USER, user);
5247 }
5248
5249 Cookie[] cookies = request.getCookies();
5250
5251 if (cookies != null) {
5252 for (Cookie cookie : cookies) {
5253 String cookieName = cookie.getName();
5254
5255 if (cookieName.startsWith(
5256 CookieKeys.REMOTE_PREFERENCE_PREFIX)) {
5257
5258 user.addRemotePreference(
5259 new CookieRemotePreference(cookie));
5260 }
5261 }
5262 }
5263
5264 return user;
5265 }
5266
5267 @Override
5268 public User getUser(PortletRequest portletRequest)
5269 throws PortalException, SystemException {
5270
5271 return getUser(getHttpServletRequest(portletRequest));
5272 }
5273
5274 @Override
5275 public String getUserEmailAddress(long userId) throws SystemException {
5276 try {
5277 User user = UserLocalServiceUtil.getUserById(userId);
5278
5279 return user.getEmailAddress();
5280 }
5281 catch (PortalException pe) {
5282 return StringPool.BLANK;
5283 }
5284 }
5285
5286 @Override
5287 public long getUserId(HttpServletRequest request) {
5288 Long userIdObj = (Long)request.getAttribute(WebKeys.USER_ID);
5289
5290 if (userIdObj != null) {
5291 return userIdObj.longValue();
5292 }
5293
5294 String path = GetterUtil.getString(request.getPathInfo());
5295 String strutsAction = getStrutsAction(request);
5296 String actionName = getPortletParam(request, "actionName");
5297
5298 boolean alwaysAllowDoAsUser = false;
5299
5300 if (path.equals("/portal/session_click") ||
5301 strutsAction.equals("/document_library/edit_file_entry") ||
5302 strutsAction.equals("/document_library_display/edit_file_entry") ||
5303 strutsAction.equals("/image_gallery_display/edit_file_entry") ||
5304 strutsAction.equals("/image_gallery_display/edit_image") ||
5305 strutsAction.equals("/wiki/edit_page_attachment") ||
5306 strutsAction.equals("/wiki_admin/edit_page_attachment") ||
5307 strutsAction.equals("/wiki_display/edit_page_attachment") ||
5308 actionName.equals("addFile")) {
5309
5310 try {
5311 alwaysAllowDoAsUser = isAlwaysAllowDoAsUser(request);
5312 }
5313 catch (Exception e) {
5314 _log.error(e, e);
5315 }
5316 }
5317
5318 if ((!PropsValues.PORTAL_JAAS_ENABLE &&
5319 PropsValues.PORTAL_IMPERSONATION_ENABLE) ||
5320 alwaysAllowDoAsUser) {
5321
5322 String doAsUserIdString = ParamUtil.getString(
5323 request, "doAsUserId");
5324
5325 try {
5326 long doAsUserId = getDoAsUserId(
5327 request, doAsUserIdString, alwaysAllowDoAsUser);
5328
5329 if (doAsUserId > 0) {
5330 if (_log.isDebugEnabled()) {
5331 _log.debug("Impersonating user " + doAsUserId);
5332 }
5333
5334 return doAsUserId;
5335 }
5336 }
5337 catch (Exception e) {
5338 _log.error("Unable to impersonate user " + doAsUserIdString, e);
5339 }
5340 }
5341
5342 HttpSession session = request.getSession();
5343
5344 userIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
5345
5346 if (userIdObj != null) {
5347 request.setAttribute(WebKeys.USER_ID, userIdObj);
5348
5349 return userIdObj.longValue();
5350 }
5351 else {
5352 return 0;
5353 }
5354 }
5355
5356 @Override
5357 public long getUserId(PortletRequest portletRequest) {
5358 return getUserId(getHttpServletRequest(portletRequest));
5359 }
5360
5361 @Override
5362 public String getUserName(BaseModel<?> baseModel) {
5363 long userId = 0;
5364 String userName = StringPool.BLANK;
5365
5366 if (baseModel instanceof AuditedModel) {
5367 AuditedModel auditedModel = (AuditedModel)baseModel;
5368
5369 userId = auditedModel.getUserId();
5370 userName = auditedModel.getUserName();
5371 }
5372 else {
5373 userId = BeanPropertiesUtil.getLongSilent(baseModel, "userId");
5374 userName = BeanPropertiesUtil.getStringSilent(
5375 baseModel, "userName");
5376 }
5377
5378 if (userId == 0) {
5379 return StringPool.BLANK;
5380 }
5381
5382 if (baseModel.isEscapedModel()) {
5383 userName = HtmlUtil.unescape(userName);
5384 }
5385
5386 userName = getUserName(userId, userName);
5387
5388 if (baseModel.isEscapedModel()) {
5389 userName = HtmlUtil.escape(userName);
5390 }
5391
5392 return userName;
5393 }
5394
5395 @Override
5396 public String getUserName(long userId, String defaultUserName) {
5397 return getUserName(
5398 userId, defaultUserName, UserAttributes.USER_NAME_FULL);
5399 }
5400
5401 @Override
5402 public String getUserName(
5403 long userId, String defaultUserName, HttpServletRequest request) {
5404
5405 return getUserName(
5406 userId, defaultUserName, UserAttributes.USER_NAME_FULL, request);
5407 }
5408
5409 @Override
5410 public String getUserName(
5411 long userId, String defaultUserName, String userAttribute) {
5412
5413 return getUserName(userId, defaultUserName, userAttribute, null);
5414 }
5415
5416 @Override
5417 public String getUserName(
5418 long userId, String defaultUserName, String userAttribute,
5419 HttpServletRequest request) {
5420
5421 String userName = defaultUserName;
5422
5423 try {
5424 User user = UserLocalServiceUtil.getUserById(userId);
5425
5426 if (userAttribute.equals(UserAttributes.USER_NAME_FULL)) {
5427 userName = user.getFullName();
5428 }
5429 else {
5430 userName = user.getScreenName();
5431 }
5432
5433 if (request != null) {
5434 Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
5435
5436 PortletURL portletURL = new PortletURLImpl(
5437 request, PortletKeys.DIRECTORY, layout.getPlid(),
5438 PortletRequest.RENDER_PHASE);
5439
5440 portletURL.setParameter(
5441 "struts_action", "/directory/view_user");
5442 portletURL.setParameter(
5443 "p_u_i_d", String.valueOf(user.getUserId()));
5444 portletURL.setPortletMode(PortletMode.VIEW);
5445 portletURL.setWindowState(WindowState.MAXIMIZED);
5446
5447 userName =
5448 "<a href=\"" + portletURL.toString() + "\">" +
5449 HtmlUtil.escape(userName) + "</a>";
5450 }
5451 }
5452 catch (Exception e) {
5453 }
5454
5455 return userName;
5456 }
5457
5458 @Override
5459 public String getUserPassword(HttpServletRequest request) {
5460 HttpSession session = request.getSession();
5461
5462 return getUserPassword(session);
5463 }
5464
5465 @Override
5466 public String getUserPassword(HttpSession session) {
5467 return (String)session.getAttribute(WebKeys.USER_PASSWORD);
5468 }
5469
5470 @Override
5471 public String getUserPassword(PortletRequest portletRequest) {
5472 return getUserPassword(getHttpServletRequest(portletRequest));
5473 }
5474
5475 @Override
5476 public String getUserValue(long userId, String param, String defaultValue)
5477 throws SystemException {
5478
5479 if (Validator.isNotNull(defaultValue)) {
5480 return defaultValue;
5481 }
5482
5483 try {
5484 User user = UserLocalServiceUtil.getUserById(userId);
5485
5486 return BeanPropertiesUtil.getString(user, param, defaultValue);
5487 }
5488 catch (PortalException pe) {
5489 return StringPool.BLANK;
5490 }
5491 }
5492
5493 @Override
5494 public long getValidUserId(long companyId, long userId)
5495 throws PortalException, SystemException {
5496
5497 User user = UserLocalServiceUtil.fetchUser(userId);
5498
5499 if (user == null) {
5500 return UserLocalServiceUtil.getDefaultUserId(companyId);
5501 }
5502
5503 if (user.getCompanyId() == companyId) {
5504 return user.getUserId();
5505 }
5506
5507 return userId;
5508 }
5509
5510 @Override
5511 public String getVirtualLayoutActualURL(
5512 long groupId, boolean privateLayout, String mainPath,
5513 String friendlyURL, Map<String, String[]> params,
5514 Map<String, Object> requestContext)
5515 throws PortalException, SystemException {
5516
5517
5518
5519 String groupFriendlyURL = null;
5520
5521 int pos = friendlyURL.indexOf(CharPool.SLASH, 3);
5522
5523 if (pos != -1) {
5524 groupFriendlyURL = friendlyURL.substring(2, pos);
5525 }
5526
5527 if (Validator.isNull(groupFriendlyURL)) {
5528 return mainPath;
5529 }
5530
5531 HttpServletRequest request = (HttpServletRequest)requestContext.get(
5532 "request");
5533
5534 long companyId = PortalInstances.getCompanyId(request);
5535
5536 Group group = GroupLocalServiceUtil.fetchFriendlyURLGroup(
5537 companyId, groupFriendlyURL);
5538
5539 if (group == null) {
5540 return mainPath;
5541 }
5542
5543
5544
5545 String layoutFriendlyURL = null;
5546
5547 if ((pos != -1) && ((pos + 1) != friendlyURL.length())) {
5548 layoutFriendlyURL = friendlyURL.substring(pos);
5549 }
5550
5551 if (Validator.isNull(layoutFriendlyURL)) {
5552 return mainPath;
5553 }
5554
5555 String actualURL = getActualURL(
5556 group.getGroupId(), privateLayout, mainPath, layoutFriendlyURL,
5557 params, requestContext);
5558
5559 return HttpUtil.addParameter(
5560 HttpUtil.removeParameter(actualURL, "p_v_l_s_g_id"), "p_v_l_s_g_id",
5561 groupId);
5562 }
5563
5564 @Override
5565 public LayoutFriendlyURLComposite getVirtualLayoutFriendlyURLComposite(
5566 boolean privateLayout, String friendlyURL,
5567 Map<String, String[]> params, Map<String, Object> requestContext)
5568 throws PortalException, SystemException {
5569
5570
5571
5572 String groupFriendlyURL = null;
5573
5574 int pos = friendlyURL.indexOf(CharPool.SLASH, 3);
5575
5576 if (pos != -1) {
5577 groupFriendlyURL = friendlyURL.substring(2, pos);
5578 }
5579
5580 HttpServletRequest request = (HttpServletRequest)requestContext.get(
5581 "request");
5582
5583 long companyId = PortalInstances.getCompanyId(request);
5584
5585 Group group = GroupLocalServiceUtil.fetchFriendlyURLGroup(
5586 companyId, groupFriendlyURL);
5587
5588
5589
5590 String layoutFriendlyURL = null;
5591
5592 if ((pos != -1) && ((pos + 1) != friendlyURL.length())) {
5593 layoutFriendlyURL = friendlyURL.substring(pos);
5594 }
5595
5596 LayoutQueryStringComposite layoutQueryStringComposite =
5597 getActualLayoutQueryStringComposite(
5598 group.getGroupId(), privateLayout, layoutFriendlyURL, params,
5599 requestContext);
5600
5601 return new LayoutFriendlyURLComposite(
5602 layoutQueryStringComposite.getLayout(), layoutFriendlyURL);
5603 }
5604
5605 @Override
5606 public String getWidgetURL(Portlet portlet, ThemeDisplay themeDisplay)
5607 throws PortalException, SystemException {
5608
5609 return getServletURL(
5610 portlet, PropsValues.WIDGET_SERVLET_MAPPING, themeDisplay);
5611 }
5612
5613 @Override
5614 public void initCustomSQL() {
5615 _customSqlKeys = new String[] {
5616 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.GROUP$]",
5617 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.LAYOUT$]",
5618 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ORGANIZATION$]",
5619 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.ROLE$]",
5620 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USER$]",
5621 "[$CLASS_NAME_ID_COM.LIFERAY.PORTAL.MODEL.USERGROUP$]",
5622 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BLOGS.MODEL.BLOGSENTRY$]",
5623 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BOOKMARKS.MODEL." +
5624 "BOOKMARKSENTRY$]",
5625 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.BOOKMARKS.MODEL." +
5626 "BOOKMARKSFOLDER$]",
5627 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.DOCUMENTLIBRARY.MODEL." +
5628 "DLFILEENTRY$]",
5629 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.DOCUMENTLIBRARY.MODEL." +
5630 "DLFOLDER$]",
5631 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.JOURNAL.MODEL." +
5632 "JOURNALFOLDER$]",
5633 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.MESSAGEBOARDS.MODEL." +
5634 "MBMESSAGE$]",
5635 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.MESSAGEBOARDS.MODEL." +
5636 "MBTHREAD$]",
5637 "[$CLASS_NAME_ID_COM.LIFERAY.PORTLET.WIKI.MODEL.WIKIPAGE$]",
5638 "[$RESOURCE_SCOPE_COMPANY$]", "[$RESOURCE_SCOPE_GROUP$]",
5639 "[$RESOURCE_SCOPE_GROUP_TEMPLATE$]",
5640 "[$RESOURCE_SCOPE_INDIVIDUAL$]",
5641 "[$SOCIAL_RELATION_TYPE_BI_COWORKER$]",
5642 "[$SOCIAL_RELATION_TYPE_BI_FRIEND$]",
5643 "[$SOCIAL_RELATION_TYPE_BI_ROMANTIC_PARTNER$]",
5644 "[$SOCIAL_RELATION_TYPE_BI_SIBLING$]",
5645 "[$SOCIAL_RELATION_TYPE_BI_SPOUSE$]",
5646 "[$SOCIAL_RELATION_TYPE_UNI_CHILD$]",
5647 "[$SOCIAL_RELATION_TYPE_UNI_ENEMY$]",
5648 "[$SOCIAL_RELATION_TYPE_UNI_FOLLOWER$]",
5649 "[$SOCIAL_RELATION_TYPE_UNI_PARENT$]",
5650 "[$SOCIAL_RELATION_TYPE_UNI_SUBORDINATE$]",
5651 "[$SOCIAL_RELATION_TYPE_UNI_SUPERVISOR$]", "[$FALSE$]", "[$TRUE$]"
5652 };
5653
5654 DB db = DBFactoryUtil.getDB();
5655
5656 Object[] customSqlValues = new Object[] {
5657 getClassNameId(Group.class), getClassNameId(Layout.class),
5658 getClassNameId(Organization.class), getClassNameId(Role.class),
5659 getClassNameId(User.class), getClassNameId(UserGroup.class),
5660 getClassNameId(BlogsEntry.class),
5661 getClassNameId(BookmarksEntry.class),
5662 getClassNameId(BookmarksFolder.class),
5663 getClassNameId(DLFileEntry.class), getClassNameId(DLFolder.class),
5664 getClassNameId(JournalFolder.class),
5665 getClassNameId(MBMessage.class), getClassNameId(MBThread.class),
5666 getClassNameId(WikiPage.class), ResourceConstants.SCOPE_COMPANY,
5667 ResourceConstants.SCOPE_GROUP,
5668 ResourceConstants.SCOPE_GROUP_TEMPLATE,
5669 ResourceConstants.SCOPE_INDIVIDUAL,
5670 SocialRelationConstants.TYPE_BI_COWORKER,
5671 SocialRelationConstants.TYPE_BI_FRIEND,
5672 SocialRelationConstants.TYPE_BI_ROMANTIC_PARTNER,
5673 SocialRelationConstants.TYPE_BI_SIBLING,
5674 SocialRelationConstants.TYPE_BI_SPOUSE,
5675 SocialRelationConstants.TYPE_UNI_CHILD,
5676 SocialRelationConstants.TYPE_UNI_ENEMY,
5677 SocialRelationConstants.TYPE_UNI_FOLLOWER,
5678 SocialRelationConstants.TYPE_UNI_PARENT,
5679 SocialRelationConstants.TYPE_UNI_SUBORDINATE,
5680 SocialRelationConstants.TYPE_UNI_SUPERVISOR, db.getTemplateFalse(),
5681 db.getTemplateTrue()
5682 };
5683
5684 _customSqlValues = ArrayUtil.toStringArray(customSqlValues);
5685 }
5686
5687 @Override
5688 public User initUser(HttpServletRequest request) throws Exception {
5689 User user = null;
5690
5691 try {
5692 user = getUser(request);
5693 }
5694 catch (NoSuchUserException nsue) {
5695 if (_log.isWarnEnabled()) {
5696 _log.warn(nsue.getMessage());
5697 }
5698
5699 long userId = getUserId(request);
5700
5701 if (userId > 0) {
5702 HttpSession session = request.getSession();
5703
5704 session.invalidate();
5705 }
5706
5707 throw nsue;
5708 }
5709
5710 if (user != null) {
5711 return user;
5712 }
5713
5714 Company company = getCompany(request);
5715
5716 return company.getDefaultUser();
5717 }
5718
5719 @Override
5720 public void invokeTaglibDiscussion(
5721 PortletConfig portletConfig, ActionRequest actionRequest,
5722 ActionResponse actionResponse)
5723 throws Exception {
5724
5725 _editDiscussionAction.processAction(
5726 null, null, portletConfig, actionRequest, actionResponse);
5727 }
5728
5729
5732 @Override
5733 public boolean isAllowAddPortletDefaultResource(
5734 HttpServletRequest request, Portlet portlet)
5735 throws PortalException, SystemException {
5736
5737 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
5738 WebKeys.THEME_DISPLAY);
5739
5740 Layout layout = themeDisplay.getLayout();
5741 LayoutTypePortlet layoutTypePortlet =
5742 themeDisplay.getLayoutTypePortlet();
5743
5744 String portletId = portlet.getPortletId();
5745
5746 Boolean renderPortletResource = (Boolean)request.getAttribute(
5747 WebKeys.RENDER_PORTLET_RESOURCE);
5748
5749 if (renderPortletResource != null) {
5750 boolean runtimePortlet = renderPortletResource.booleanValue();
5751
5752 if (runtimePortlet) {
5753 return true;
5754 }
5755 }
5756
5757 if (layout.isTypePanel() &&
5758 isPanelSelectedPortlet(themeDisplay, portletId)) {
5759
5760 return true;
5761 }
5762
5763 if (layout.isTypeControlPanel() &&
5764 isControlPanelPortlet(portletId, themeDisplay)) {
5765
5766 return true;
5767 }
5768
5769 if ((layoutTypePortlet != null) &&
5770 layoutTypePortlet.hasPortletId(portletId)) {
5771
5772 return true;
5773 }
5774
5775 if (themeDisplay.isSignedIn() &&
5776 portletId.equals(PortletKeys.LAYOUTS_ADMIN)) {
5777
5778 PermissionChecker permissionChecker =
5779 themeDisplay.getPermissionChecker();
5780
5781 Group group = layout.getGroup();
5782
5783 if (group.isSite()) {
5784 if (LayoutPermissionUtil.contains(
5785 permissionChecker, layout, ActionKeys.CUSTOMIZE) ||
5786 LayoutPermissionUtil.contains(
5787 permissionChecker, layout, ActionKeys.UPDATE)) {
5788
5789 return true;
5790 }
5791 }
5792
5793 if (group.isCompany()) {
5794 if (permissionChecker.isCompanyAdmin()) {
5795 return true;
5796 }
5797 }
5798 else if (group.isLayoutPrototype()) {
5799 long layoutPrototypeId = group.getClassPK();
5800
5801 if (LayoutPrototypePermissionUtil.contains(
5802 permissionChecker, layoutPrototypeId,
5803 ActionKeys.UPDATE)) {
5804
5805 return true;
5806 }
5807 }
5808 else if (group.isLayoutSetPrototype()) {
5809 long layoutSetPrototypeId = group.getClassPK();
5810
5811 if (LayoutSetPrototypePermissionUtil.contains(
5812 permissionChecker, layoutSetPrototypeId,
5813 ActionKeys.UPDATE)) {
5814
5815 return true;
5816 }
5817 }
5818 else if (group.isOrganization()) {
5819 long organizationId = group.getOrganizationId();
5820
5821 if (OrganizationPermissionUtil.contains(
5822 permissionChecker, organizationId, ActionKeys.UPDATE)) {
5823
5824 return true;
5825 }
5826 }
5827 else if (group.isUserGroup()) {
5828 long scopeGroupId = themeDisplay.getScopeGroupId();
5829
5830 if (GroupPermissionUtil.contains(
5831 permissionChecker, scopeGroupId, ActionKeys.UPDATE)) {
5832
5833 return true;
5834 }
5835 }
5836 else if (group.isUser()) {
5837 return true;
5838 }
5839 }
5840
5841 if (!portlet.isAddDefaultResource()) {
5842 return false;
5843 }
5844
5845 if (!PropsValues.PORTLET_ADD_DEFAULT_RESOURCE_CHECK_ENABLED) {
5846 return true;
5847 }
5848
5849 Set<String> whiteList =
5850 AuthTokenWhitelistUtil.getPortletInvocationWhitelist();
5851
5852 if (whiteList.contains(portletId)) {
5853 return true;
5854 }
5855
5856 String namespace = getPortletNamespace(portletId);
5857
5858 String strutsAction = ParamUtil.getString(
5859 request, namespace + "struts_action");
5860
5861 if (Validator.isNull(strutsAction)) {
5862 strutsAction = ParamUtil.getString(request, "struts_action");
5863 }
5864
5865 Set<String> whitelistActions =
5866 AuthTokenWhitelistUtil.getPortletInvocationWhitelistActions();
5867
5868 if (whitelistActions.contains(strutsAction)) {
5869 return true;
5870 }
5871
5872 String requestPortletAuthenticationToken = ParamUtil.getString(
5873 request, "p_p_auth");
5874
5875 if (Validator.isNull(requestPortletAuthenticationToken)) {
5876 HttpServletRequest originalRequest = getOriginalServletRequest(
5877 request);
5878
5879 requestPortletAuthenticationToken = ParamUtil.getString(
5880 originalRequest, "p_p_auth");
5881 }
5882
5883 if (Validator.isNotNull(requestPortletAuthenticationToken)) {
5884 String actualPortletAuthenticationToken = AuthTokenUtil.getToken(
5885 request, layout.getPlid(), portletId);
5886
5887 if (requestPortletAuthenticationToken.equals(
5888 actualPortletAuthenticationToken)) {
5889
5890 return true;
5891 }
5892 }
5893
5894 return false;
5895 }
5896
5897 @Override
5898 public boolean isCDNDynamicResourcesEnabled(HttpServletRequest request)
5899 throws PortalException, SystemException {
5900
5901 Company company = getCompany(request);
5902
5903 return isCDNDynamicResourcesEnabled(company.getCompanyId());
5904 }
5905
5906 @Override
5907 public boolean isCDNDynamicResourcesEnabled(long companyId) {
5908 try {
5909 return PrefsPropsUtil.getBoolean(
5910 companyId, PropsKeys.CDN_DYNAMIC_RESOURCES_ENABLED,
5911 PropsValues.CDN_DYNAMIC_RESOURCES_ENABLED);
5912 }
5913 catch (SystemException se) {
5914 }
5915
5916 return PropsValues.CDN_DYNAMIC_RESOURCES_ENABLED;
5917 }
5918
5919
5922 @Override
5923 public boolean isCommunityAdmin(User user, long groupId) throws Exception {
5924 return isGroupAdmin(user, groupId);
5925 }
5926
5927
5930 @Override
5931 public boolean isCommunityOwner(User user, long groupId) throws Exception {
5932 return isGroupOwner(user, groupId);
5933 }
5934
5935 @Override
5936 public boolean isCompanyAdmin(User user) throws Exception {
5937 PermissionChecker permissionChecker =
5938 PermissionCheckerFactoryUtil.create(user);
5939
5940 return permissionChecker.isCompanyAdmin();
5941 }
5942
5943 @Override
5944 public boolean isCompanyControlPanelPortlet(
5945 String portletId, String category, ThemeDisplay themeDisplay)
5946 throws PortalException, SystemException {
5947
5948 PermissionChecker permissionChecker =
5949 themeDisplay.getPermissionChecker();
5950
5951 if (permissionChecker.isCompanyAdmin()) {
5952 return true;
5953 }
5954
5955 Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
5956 themeDisplay.getCompanyId());
5957
5958 themeDisplay.setScopeGroupId(companyGroup.getGroupId());
5959
5960 return isControlPanelPortlet(portletId, category, themeDisplay);
5961 }
5962
5963 @Override
5964 public boolean isCompanyControlPanelPortlet(
5965 String portletId, ThemeDisplay themeDisplay)
5966 throws PortalException, SystemException {
5967
5968 PermissionChecker permissionChecker =
5969 themeDisplay.getPermissionChecker();
5970
5971 if (permissionChecker.isCompanyAdmin()) {
5972 return true;
5973 }
5974
5975 Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
5976 themeDisplay.getCompanyId());
5977
5978 themeDisplay.setScopeGroupId(companyGroup.getGroupId());
5979
5980 return isControlPanelPortlet(portletId, themeDisplay);
5981 }
5982
5983 @Override
5984 public boolean isCompanyControlPanelVisible(ThemeDisplay themeDisplay)
5985 throws PortalException, SystemException {
5986
5987 PermissionChecker permissionChecker =
5988 themeDisplay.getPermissionChecker();
5989
5990 if (permissionChecker.isCompanyAdmin()) {
5991 return true;
5992 }
5993
5994 long scopeGroupId = themeDisplay.getScopeGroupId();
5995
5996 try {
5997 Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
5998 themeDisplay.getCompanyId());
5999
6000 themeDisplay.setScopeGroupId(companyGroup.getGroupId());
6001
6002 List<Portlet> controlPanelPortlets = getControlPanelPortlets(
6003 PortletCategoryKeys.SITE_ADMINISTRATION, themeDisplay);
6004
6005 if (!controlPanelPortlets.isEmpty()) {
6006 return true;
6007 }
6008 else {
6009 return false;
6010 }
6011 }
6012 finally {
6013 themeDisplay.setScopeGroupId(scopeGroupId);
6014 }
6015 }
6016
6017 @Override
6018 public boolean isControlPanelPortlet(
6019 String portletId, String category, ThemeDisplay themeDisplay)
6020 throws SystemException {
6021
6022 Portlet portlet = PortletLocalServiceUtil.getPortletById(
6023 themeDisplay.getCompanyId(), portletId);
6024
6025 String controlPanelEntryCategory =
6026 portlet.getControlPanelEntryCategory();
6027
6028 if (controlPanelEntryCategory.equals(category) ||
6029 (category.endsWith(StringPool.PERIOD) &&
6030 StringUtil.startsWith(controlPanelEntryCategory, category))) {
6031
6032 return isControlPanelPortlet(portletId, themeDisplay);
6033 }
6034
6035 return false;
6036 }
6037
6038 @Override
6039 public boolean isControlPanelPortlet(
6040 String portletId, ThemeDisplay themeDisplay)
6041 throws SystemException {
6042
6043 try {
6044 return PortletPermissionUtil.hasControlPanelAccessPermission(
6045 themeDisplay.getPermissionChecker(),
6046 themeDisplay.getScopeGroupId(), portletId);
6047 }
6048 catch (PortalException pe) {
6049 _log.warn("Unable to check control panel access permission", pe);
6050 }
6051
6052 return false;
6053 }
6054
6055 @Override
6056 public boolean isGroupAdmin(User user, long groupId) throws Exception {
6057 PermissionChecker permissionChecker =
6058 PermissionCheckerFactoryUtil.create(user);
6059
6060 return permissionChecker.isGroupAdmin(groupId);
6061 }
6062
6063 @Override
6064 public boolean isGroupFriendlyURL(
6065 String fullURL, String groupFriendlyURL, String layoutFriendlyURL) {
6066
6067 if (fullURL.endsWith(groupFriendlyURL) &&
6068 !fullURL.endsWith(groupFriendlyURL.concat(layoutFriendlyURL))) {
6069
6070 return true;
6071 }
6072
6073 return false;
6074 }
6075
6076 @Override
6077 public boolean isGroupOwner(User user, long groupId) throws Exception {
6078 PermissionChecker permissionChecker =
6079 PermissionCheckerFactoryUtil.create(user);
6080
6081 return permissionChecker.isGroupOwner(groupId);
6082 }
6083
6084 @Override
6085 public boolean isLayoutDescendant(Layout layout, long layoutId)
6086 throws PortalException, SystemException {
6087
6088 if (layout.getLayoutId() == layoutId) {
6089 return true;
6090 }
6091
6092 for (Layout childLayout : layout.getChildren()) {
6093 if (isLayoutDescendant(childLayout, layoutId)) {
6094 return true;
6095 }
6096 }
6097
6098 return false;
6099 }
6100
6101 @Override
6102 public boolean isLayoutFirstPageable(Layout layout) {
6103 LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
6104
6105 return layoutSettings.isFirstPageable();
6106 }
6107
6108 @Override
6109 public boolean isLayoutFirstPageable(String type) {
6110 LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
6111
6112 return layoutSettings.isFirstPageable();
6113 }
6114
6115 @Override
6116 public boolean isLayoutFriendliable(Layout layout) {
6117 LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
6118
6119 return layoutSettings.isURLFriendliable();
6120 }
6121
6122 @Override
6123 public boolean isLayoutFriendliable(String type) {
6124 LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
6125
6126 return layoutSettings.isURLFriendliable();
6127 }
6128
6129 @Override
6130 public boolean isLayoutParentable(Layout layout) {
6131 return isLayoutParentable(layout.getType());
6132 }
6133
6134 @Override
6135 public boolean isLayoutParentable(String type) {
6136 LayoutSettings layoutSettings = LayoutSettings.getInstance(type);
6137
6138 return layoutSettings.isParentable();
6139 }
6140
6141 @Override
6142 public boolean isLayoutSitemapable(Layout layout) {
6143 if (layout.isPrivateLayout()) {
6144 return false;
6145 }
6146
6147 LayoutSettings layoutSettings = LayoutSettings.getInstance(layout);
6148
6149 return layoutSettings.isSitemapable();
6150 }
6151
6152 @Override
6153 public boolean isLoginRedirectRequired(HttpServletRequest request)
6154 throws SystemException {
6155
6156 if (PropsValues.COMPANY_SECURITY_AUTH_REQUIRES_HTTPS &&
6157 !request.isSecure()) {
6158
6159 return true;
6160 }
6161
6162 long companyId = PortalUtil.getCompanyId(request);
6163
6164 if (PrefsPropsUtil.getBoolean(
6165 companyId, PropsKeys.CAS_AUTH_ENABLED,
6166 PropsValues.CAS_AUTH_ENABLED) ||
6167 PrefsPropsUtil.getBoolean(
6168 companyId, PropsKeys.LOGIN_DIALOG_DISABLED,
6169 PropsValues.LOGIN_DIALOG_DISABLED) ||
6170 PrefsPropsUtil.getBoolean(
6171 companyId, PropsKeys.NTLM_AUTH_ENABLED,
6172 PropsValues.NTLM_AUTH_ENABLED) ||
6173 PrefsPropsUtil.getBoolean(
6174 companyId, PropsKeys.OPEN_SSO_AUTH_ENABLED,
6175 PropsValues.OPEN_SSO_AUTH_ENABLED)) {
6176
6177 return true;
6178 }
6179
6180 return false;
6181 }
6182
6183 @Override
6184 public boolean isMethodGet(PortletRequest portletRequest) {
6185 HttpServletRequest request = getHttpServletRequest(portletRequest);
6186
6187 String method = GetterUtil.getString(request.getMethod());
6188
6189 if (StringUtil.equalsIgnoreCase(method, HttpMethods.GET)) {
6190 return true;
6191 }
6192 else {
6193 return false;
6194 }
6195 }
6196
6197 @Override
6198 public boolean isMethodPost(PortletRequest portletRequest) {
6199 HttpServletRequest request = getHttpServletRequest(portletRequest);
6200
6201 String method = GetterUtil.getString(request.getMethod());
6202
6203 if (StringUtil.equalsIgnoreCase(method, HttpMethods.POST)) {
6204 return true;
6205 }
6206 else {
6207 return false;
6208 }
6209 }
6210
6211 @Override
6212 public boolean isMultipartRequest(HttpServletRequest request) {
6213 String contentType = request.getHeader(HttpHeaders.CONTENT_TYPE);
6214
6215 if ((contentType != null) &&
6216 contentType.startsWith(ContentTypes.MULTIPART_FORM_DATA)) {
6217
6218 return true;
6219 }
6220 else {
6221 return false;
6222 }
6223 }
6224
6225 @Override
6226 public boolean isOmniadmin(long userId) {
6227 return OmniadminUtil.isOmniadmin(userId);
6228 }
6229
6230 @Override
6231 public boolean isReservedParameter(String name) {
6232 return _reservedParams.contains(name);
6233 }
6234
6235 @Override
6236 public boolean isRSSFeedsEnabled() {
6237 return PropsValues.RSS_FEEDS_ENABLED;
6238 }
6239
6240 @Override
6241 public boolean isSecure(HttpServletRequest request) {
6242 HttpSession session = request.getSession();
6243
6244 if (session == null) {
6245 return request.isSecure();
6246 }
6247
6248 Boolean httpsInitial = (Boolean)session.getAttribute(
6249 WebKeys.HTTPS_INITIAL);
6250
6251 boolean secure = false;
6252
6253 if (PropsValues.COMPANY_SECURITY_AUTH_REQUIRES_HTTPS &&
6254 !PropsValues.SESSION_ENABLE_PHISHING_PROTECTION &&
6255 (httpsInitial != null) && !httpsInitial.booleanValue()) {
6256
6257 secure = false;
6258 }
6259 else {
6260 secure = request.isSecure();
6261 }
6262
6263 return secure;
6264 }
6265
6266 @Override
6267 public boolean isSystemGroup(String groupName) {
6268 if (groupName == null) {
6269 return false;
6270 }
6271
6272 groupName = groupName.trim();
6273
6274 int pos = Arrays.binarySearch(
6275 _sortedSystemGroups, groupName, new StringComparator());
6276
6277 if (pos >= 0) {
6278 return true;
6279 }
6280 else {
6281 return false;
6282 }
6283 }
6284
6285 @Override
6286 public boolean isSystemRole(String roleName) {
6287 if (roleName == null) {
6288 return false;
6289 }
6290
6291 roleName = roleName.trim();
6292
6293 int pos = Arrays.binarySearch(
6294 _sortedSystemRoles, roleName, new StringComparator());
6295
6296 if (pos >= 0) {
6297 return true;
6298 }
6299
6300 pos = Arrays.binarySearch(
6301 _sortedSystemSiteRoles, roleName, new StringComparator());
6302
6303 if (pos >= 0) {
6304 return true;
6305 }
6306
6307 pos = Arrays.binarySearch(
6308 _sortedSystemOrganizationRoles, roleName, new StringComparator());
6309
6310 if (pos >= 0) {
6311 return true;
6312 }
6313
6314 return false;
6315 }
6316
6317 @Override
6318 public boolean isUpdateAvailable() throws SystemException {
6319 return PluginPackageUtil.isUpdateAvailable();
6320 }
6321
6322 @Override
6323 public boolean isValidResourceId(String resourceId) {
6324 if (Validator.isNull(resourceId)) {
6325 return true;
6326 }
6327
6328 Matcher matcher = _bannedResourceIdPattern.matcher(resourceId);
6329
6330 if (matcher.matches()) {
6331 return false;
6332 }
6333
6334 return true;
6335 }
6336
6337 @Override
6338 public void removePortalPortEventListener(
6339 PortalPortEventListener portalPortEventListener) {
6340
6341 _portalPortEventListeners.remove(portalPortEventListener);
6342 }
6343
6344 @Override
6345 public void resetCDNHosts() {
6346 _cdnHostHttpMap.clear();
6347 _cdnHostHttpsMap.clear();
6348
6349 if (!ClusterInvokeThreadLocal.isEnabled()) {
6350 return;
6351 }
6352
6353 ClusterRequest clusterRequest = ClusterRequest.createMulticastRequest(
6354 _resetCDNHostsMethodHandler, true);
6355
6356 try {
6357 ClusterExecutorUtil.execute(clusterRequest);
6358 }
6359 catch (Exception e) {
6360 _log.error("Unable to clear cluster wide CDN hosts", e);
6361 }
6362 }
6363
6364
6368 @Override
6369 public Set<String> resetPortletAddDefaultResourceCheckWhitelist() {
6370 return AuthTokenWhitelistUtil.resetPortletInvocationWhitelist();
6371 }
6372
6373
6377 @Override
6378 public Set<String> resetPortletAddDefaultResourceCheckWhitelistActions() {
6379 return AuthTokenWhitelistUtil.resetPortletInvocationWhitelistActions();
6380 }
6381
6382 @Override
6383 public void sendError(
6384 Exception e, ActionRequest actionRequest,
6385 ActionResponse actionResponse)
6386 throws IOException {
6387
6388 sendError(0, e, actionRequest, actionResponse);
6389 }
6390
6391 @Override
6392 public void sendError(
6393 Exception e, HttpServletRequest request,
6394 HttpServletResponse response)
6395 throws IOException, ServletException {
6396
6397 sendError(0, e, request, response);
6398 }
6399
6400 @Override
6401 public void sendError(
6402 int status, Exception e, ActionRequest actionRequest,
6403 ActionResponse actionResponse)
6404 throws IOException {
6405
6406 StringBundler sb = new StringBundler(7);
6407
6408 sb.append(_pathMain);
6409 sb.append("/portal/status?status=");
6410 sb.append(status);
6411 sb.append("&exception=");
6412 sb.append(e.getClass().getName());
6413 sb.append("&previousURL=");
6414 sb.append(HttpUtil.encodeURL(getCurrentURL(actionRequest)));
6415
6416 actionResponse.sendRedirect(sb.toString());
6417 }
6418
6419 @Override
6420 public void sendError(
6421 int status, Exception e, HttpServletRequest request,
6422 HttpServletResponse response)
6423 throws IOException, ServletException {
6424
6425 if (_log.isDebugEnabled()) {
6426 String currentURL = (String)request.getAttribute(
6427 WebKeys.CURRENT_URL);
6428
6429 _log.debug(
6430 "Current URL " + currentURL + " generates exception: " +
6431 e.getMessage());
6432 }
6433
6434 if (e instanceof NoSuchImageException) {
6435 if (_logWebServerServlet.isWarnEnabled()) {
6436 _logWebServerServlet.warn(e, e);
6437 }
6438 }
6439 else if ((e instanceof PortalException) && _log.isDebugEnabled()) {
6440 if ((e instanceof NoSuchLayoutException) ||
6441 (e instanceof PrincipalException)) {
6442
6443 String msg = e.getMessage();
6444
6445 if (Validator.isNotNull(msg)) {
6446 _log.debug(msg);
6447 }
6448 }
6449 else {
6450 _log.debug(e, e);
6451 }
6452 }
6453 else if ((e instanceof SystemException) && _log.isWarnEnabled()) {
6454 _log.warn(e, e);
6455 }
6456
6457 if (response.isCommitted()) {
6458 return;
6459 }
6460
6461 if (status == 0) {
6462 if (e instanceof PrincipalException) {
6463 status = HttpServletResponse.SC_FORBIDDEN;
6464 }
6465 else {
6466 String name = e.getClass().getName();
6467
6468 name = name.substring(name.lastIndexOf(CharPool.PERIOD) + 1);
6469
6470 if (name.startsWith("NoSuch") && name.endsWith("Exception")) {
6471 status = HttpServletResponse.SC_NOT_FOUND;
6472 }
6473 }
6474
6475 if (status == 0) {
6476
6477
6478
6479 if (PropsValues.TCK_URL) {
6480 status = HttpServletResponse.SC_INTERNAL_SERVER_ERROR;
6481 }
6482 else {
6483 status = HttpServletResponse.SC_BAD_REQUEST;
6484 }
6485 }
6486 }
6487
6488 HttpSession session = PortalSessionThreadLocal.getHttpSession();
6489
6490 if (session == null) {
6491 session = request.getSession();
6492 }
6493
6494 ServletContext servletContext = session.getServletContext();
6495
6496 String redirect = PATH_MAIN + "/portal/status";
6497
6498 if ((e instanceof NoSuchLayoutException) &&
6499 Validator.isNotNull(
6500 PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND)) {
6501
6502 response.setStatus(status);
6503
6504 redirect = PropsValues.LAYOUT_FRIENDLY_URL_PAGE_NOT_FOUND;
6505
6506 RequestDispatcher requestDispatcher =
6507 servletContext.getRequestDispatcher(redirect);
6508
6509 if (requestDispatcher != null) {
6510 requestDispatcher.forward(request, response);
6511 }
6512 }
6513 else if (PropsValues.LAYOUT_SHOW_HTTP_STATUS) {
6514 response.setStatus(status);
6515
6516 SessionErrors.add(session, e.getClass(), e);
6517
6518 RequestDispatcher requestDispatcher =
6519 servletContext.getRequestDispatcher(redirect);
6520
6521 if (requestDispatcher != null) {
6522 requestDispatcher.forward(request, response);
6523 }
6524 }
6525 else if (e != null) {
6526 response.sendError(status, e.getMessage());
6527 }
6528 else {
6529 String currentURL = (String)request.getAttribute(
6530 WebKeys.CURRENT_URL);
6531
6532 response.sendError(status, "Current URL " + currentURL);
6533 }
6534 }
6535
6536 @Override
6537 public void sendRSSFeedsDisabledError(
6538 HttpServletRequest request, HttpServletResponse response)
6539 throws IOException, ServletException {
6540
6541 sendError(
6542 HttpServletResponse.SC_NOT_FOUND, new NoSuchFeedException(),
6543 request, response);
6544 }
6545
6546 @Override
6547 public void sendRSSFeedsDisabledError(
6548 PortletRequest portletRequest, PortletResponse portletResponse)
6549 throws IOException, ServletException {
6550
6551 HttpServletRequest request = getHttpServletRequest(portletRequest);
6552 HttpServletResponse response = getHttpServletResponse(portletResponse);
6553
6554 sendRSSFeedsDisabledError(request, response);
6555 }
6556
6557 @Override
6558 public void setPageDescription(
6559 String description, HttpServletRequest request) {
6560
6561 ListMergeable<String> descriptionListMergeable =
6562 new ListMergeable<String>();
6563
6564 descriptionListMergeable.add(description);
6565
6566 request.setAttribute(
6567 WebKeys.PAGE_DESCRIPTION, descriptionListMergeable);
6568 }
6569
6570 @Override
6571 public void setPageKeywords(String keywords, HttpServletRequest request) {
6572 request.removeAttribute(WebKeys.PAGE_KEYWORDS);
6573
6574 addPageKeywords(keywords, request);
6575 }
6576
6577 @Override
6578 public void setPageSubtitle(String subtitle, HttpServletRequest request) {
6579 ListMergeable<String> subtitleListMergeable =
6580 new ListMergeable<String>();
6581
6582 subtitleListMergeable.add(subtitle);
6583
6584 request.setAttribute(WebKeys.PAGE_SUBTITLE, subtitleListMergeable);
6585 }
6586
6587 @Override
6588 public void setPageTitle(String title, HttpServletRequest request) {
6589 ListMergeable<String> titleListMergeable = new ListMergeable<String>();
6590
6591 titleListMergeable.add(title);
6592
6593 request.setAttribute(WebKeys.PAGE_TITLE, titleListMergeable);
6594 }
6595
6596 @Override
6597 public void setPortalPort(HttpServletRequest request) {
6598 if (request.isSecure()) {
6599 if (_securePortalPort.get() == -1) {
6600 int securePortalPort = request.getServerPort();
6601
6602 _securePortalPort.compareAndSet(-1, securePortalPort);
6603 }
6604 }
6605 else {
6606 if (_portalPort.get() == -1) {
6607 int portalPort = request.getServerPort();
6608
6609 if (_portalPort.compareAndSet(-1, portalPort)) {
6610 notifyPortalPortEventListeners(portalPort);
6611 }
6612 }
6613 }
6614 }
6615
6616 @Override
6617 public void storePreferences(PortletPreferences portletPreferences)
6618 throws IOException, ValidatorException {
6619
6620 PortletPreferencesWrapper portletPreferencesWrapper =
6621 (PortletPreferencesWrapper)portletPreferences;
6622
6623 PortletPreferencesImpl portletPreferencesImpl =
6624 portletPreferencesWrapper.getPortletPreferencesImpl();
6625
6626 portletPreferencesImpl.store();
6627 }
6628
6629 @Override
6630 public String[] stripURLAnchor(String url, String separator) {
6631 String anchor = StringPool.BLANK;
6632
6633 int pos = url.indexOf(separator);
6634
6635 if (pos != -1) {
6636 anchor = url.substring(pos);
6637 url = url.substring(0, pos);
6638 }
6639
6640 return new String[] {url, anchor};
6641 }
6642
6643 @Override
6644 public String transformCustomSQL(String sql) {
6645 if ((_customSqlKeys == null) || (_customSqlValues == null)) {
6646 initCustomSQL();
6647 }
6648
6649 return StringUtil.replace(sql, _customSqlKeys, _customSqlValues);
6650 }
6651
6652 @Override
6653 public String transformSQL(String sql) {
6654 return SQLTransformer.transform(sql);
6655 }
6656
6657 @Override
6658 public PortletMode updatePortletMode(
6659 String portletId, User user, Layout layout, PortletMode portletMode,
6660 HttpServletRequest request) {
6661
6662 LayoutTypePortlet layoutType =
6663 (LayoutTypePortlet)layout.getLayoutType();
6664
6665 if ((portletMode == null) || Validator.isNull(portletMode.toString())) {
6666 if (layoutType.hasModeAboutPortletId(portletId)) {
6667 return LiferayPortletMode.ABOUT;
6668 }
6669 else if (layoutType.hasModeConfigPortletId(portletId)) {
6670 return LiferayPortletMode.CONFIG;
6671 }
6672 else if (layoutType.hasModeEditPortletId(portletId)) {
6673 return PortletMode.EDIT;
6674 }
6675 else if (layoutType.hasModeEditDefaultsPortletId(portletId)) {
6676 return LiferayPortletMode.EDIT_DEFAULTS;
6677 }
6678 else if (layoutType.hasModeEditGuestPortletId(portletId)) {
6679 return LiferayPortletMode.EDIT_GUEST;
6680 }
6681 else if (layoutType.hasModeHelpPortletId(portletId)) {
6682 return PortletMode.HELP;
6683 }
6684 else if (layoutType.hasModePreviewPortletId(portletId)) {
6685 return LiferayPortletMode.PREVIEW;
6686 }
6687 else if (layoutType.hasModePrintPortletId(portletId)) {
6688 return LiferayPortletMode.PRINT;
6689 }
6690 else {
6691 return PortletMode.VIEW;
6692 }
6693 }
6694 else {
6695 boolean updateLayout = false;
6696
6697 if (portletMode.equals(LiferayPortletMode.ABOUT) &&
6698 !layoutType.hasModeAboutPortletId(portletId)) {
6699
6700 layoutType.addModeAboutPortletId(portletId);
6701
6702 updateLayout = true;
6703 }
6704 else if (portletMode.equals(LiferayPortletMode.CONFIG) &&
6705 !layoutType.hasModeConfigPortletId(portletId)) {
6706
6707 layoutType.addModeConfigPortletId(portletId);
6708
6709 updateLayout = true;
6710 }
6711 else if (portletMode.equals(PortletMode.EDIT) &&
6712 !layoutType.hasModeEditPortletId(portletId)) {
6713
6714 layoutType.addModeEditPortletId(portletId);
6715
6716 updateLayout = true;
6717 }
6718 else if (portletMode.equals(LiferayPortletMode.EDIT_DEFAULTS) &&
6719 !layoutType.hasModeEditDefaultsPortletId(portletId)) {
6720
6721 layoutType.addModeEditDefaultsPortletId(portletId);
6722
6723 updateLayout = true;
6724 }
6725 else if (portletMode.equals(LiferayPortletMode.EDIT_GUEST) &&
6726 !layoutType.hasModeEditGuestPortletId(portletId)) {
6727
6728 layoutType.addModeEditGuestPortletId(portletId);
6729
6730 updateLayout = true;
6731 }
6732 else if (portletMode.equals(PortletMode.HELP) &&
6733 !layoutType.hasModeHelpPortletId(portletId)) {
6734
6735 layoutType.addModeHelpPortletId(portletId);
6736
6737 updateLayout = true;
6738 }
6739 else if (portletMode.equals(LiferayPortletMode.PREVIEW) &&
6740 !layoutType.hasModePreviewPortletId(portletId)) {
6741
6742 layoutType.addModePreviewPortletId(portletId);
6743
6744 updateLayout = true;
6745 }
6746 else if (portletMode.equals(LiferayPortletMode.PRINT) &&
6747 !layoutType.hasModePrintPortletId(portletId)) {
6748
6749 layoutType.addModePrintPortletId(portletId);
6750
6751 updateLayout = true;
6752 }
6753 else if (portletMode.equals(PortletMode.VIEW) &&
6754 !layoutType.hasModeViewPortletId(portletId)) {
6755
6756 layoutType.removeModesPortletId(portletId);
6757
6758 updateLayout = true;
6759 }
6760
6761 if (updateLayout) {
6762 LayoutClone layoutClone = LayoutCloneFactory.getInstance();
6763
6764 if (layoutClone != null) {
6765 layoutClone.update(
6766 request, layout.getPlid(), layout.getTypeSettings());
6767 }
6768 }
6769
6770 return portletMode;
6771 }
6772 }
6773
6774 @Override
6775 public String updateRedirect(
6776 String redirect, String oldPath, String newPath) {
6777
6778 if (Validator.isNull(redirect) || (oldPath == null) ||
6779 oldPath.equals(newPath)) {
6780
6781 return redirect;
6782 }
6783
6784 String queryString = HttpUtil.getQueryString(redirect);
6785
6786 String redirectParam = HttpUtil.getParameter(
6787 redirect, "redirect", false);
6788
6789 if (Validator.isNotNull(redirectParam)) {
6790 String newRedirectParam = StringUtil.replace(
6791 redirectParam, HttpUtil.encodeURL(oldPath),
6792 HttpUtil.encodeURL(newPath));
6793
6794 queryString = StringUtil.replace(
6795 queryString, redirectParam, newRedirectParam);
6796 }
6797
6798 String redirectPath = HttpUtil.getPath(redirect);
6799
6800 int pos = redirect.indexOf(redirectPath);
6801
6802 String prefix = redirect.substring(0, pos);
6803
6804 pos = redirectPath.lastIndexOf(oldPath);
6805
6806 if (pos != -1) {
6807 prefix += redirectPath.substring(0, pos);
6808
6809 String suffix = redirectPath.substring(pos + oldPath.length());
6810
6811 redirect = prefix + newPath + suffix;
6812 }
6813 else {
6814 redirect = prefix + redirectPath;
6815 }
6816
6817 if (Validator.isNotNull(queryString)) {
6818 redirect += StringPool.QUESTION + queryString;
6819 }
6820
6821 return redirect;
6822 }
6823
6824 @Override
6825 public WindowState updateWindowState(
6826 String portletId, User user, Layout layout, WindowState windowState,
6827 HttpServletRequest request) {
6828
6829 LayoutTypePortlet layoutType =
6830 (LayoutTypePortlet)layout.getLayoutType();
6831
6832 if ((windowState == null) || Validator.isNull(windowState.toString())) {
6833 if (layoutType.hasStateMaxPortletId(portletId)) {
6834 windowState = WindowState.MAXIMIZED;
6835 }
6836 else if (layoutType.hasStateMinPortletId(portletId)) {
6837 windowState = WindowState.MINIMIZED;
6838 }
6839 else {
6840 windowState = WindowState.NORMAL;
6841 }
6842 }
6843 else {
6844 boolean updateLayout = false;
6845
6846 if (windowState.equals(WindowState.MAXIMIZED) &&
6847 !layoutType.hasStateMaxPortletId(portletId)) {
6848
6849 layoutType.addStateMaxPortletId(portletId);
6850
6851 if (PropsValues.LAYOUT_REMEMBER_MAXIMIZED_WINDOW_STATE) {
6852 updateLayout = true;
6853 }
6854 }
6855 else if (windowState.equals(WindowState.MINIMIZED) &&
6856 !layoutType.hasStateMinPortletId(portletId)) {
6857
6858 layoutType.addStateMinPortletId(portletId);
6859
6860 updateLayout = true;
6861 }
6862 else if (windowState.equals(WindowState.NORMAL) &&
6863 !layoutType.hasStateNormalPortletId(portletId)) {
6864
6865 layoutType.removeStatesPortletId(portletId);
6866
6867 updateLayout = true;
6868 }
6869
6870 if (portletId.equals(PortletKeys.LAYOUTS_ADMIN) ||
6871 portletId.equals(PortletKeys.PORTLET_CONFIGURATION)) {
6872
6873 updateLayout = false;
6874 }
6875
6876 if (updateLayout) {
6877 LayoutClone layoutClone = LayoutCloneFactory.getInstance();
6878
6879 if (layoutClone != null) {
6880 layoutClone.update(
6881 request, layout.getPlid(), layout.getTypeSettings());
6882 }
6883 }
6884 }
6885
6886 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
6887 WebKeys.THEME_DISPLAY);
6888
6889 themeDisplay.setStateExclusive(
6890 windowState.equals(LiferayWindowState.EXCLUSIVE));
6891 themeDisplay.setStateMaximized(
6892 windowState.equals(WindowState.MAXIMIZED));
6893 themeDisplay.setStatePopUp(
6894 windowState.equals(LiferayWindowState.POP_UP));
6895
6896 if (themeDisplay.isStateMaximized() &&
6897 themeDisplay.isShowAddContentIcon()) {
6898
6899 themeDisplay.setShowAddContentIcon(false);
6900 }
6901 else if (!themeDisplay.isStateMaximized() &&
6902 !themeDisplay.isShowAddContentIcon() &&
6903 themeDisplay.isShowAddContentIconPermission()) {
6904
6905 themeDisplay.setShowAddContentIcon(true);
6906 }
6907
6908 request.setAttribute(WebKeys.WINDOW_STATE, windowState);
6909
6910 return windowState;
6911 }
6912
6913 protected void addDefaultResource(
6914 long companyId, Layout layout, Portlet portlet,
6915 boolean portletActions)
6916 throws PortalException, SystemException {
6917
6918 long groupId = getScopeGroupId(layout, portlet.getPortletId());
6919
6920 addDefaultResource(companyId, groupId, layout, portlet, portletActions);
6921 }
6922
6923 protected void addDefaultResource(
6924 long companyId, long groupId, Layout layout, Portlet portlet,
6925 boolean portletActions)
6926 throws PortalException, SystemException {
6927
6928 String rootPortletId = portlet.getRootPortletId();
6929
6930 String portletPrimaryKey = PortletPermissionUtil.getPrimaryKey(
6931 layout.getPlid(), portlet.getPortletId());
6932
6933 String name = null;
6934 String primaryKey = null;
6935
6936 if (portletActions) {
6937 name = rootPortletId;
6938 primaryKey = portletPrimaryKey;
6939 }
6940 else {
6941 Group group = GroupLocalServiceUtil.fetchGroup(groupId);
6942
6943 if ((group != null) && group.isStagingGroup()) {
6944 groupId = group.getLiveGroupId();
6945 }
6946
6947 name = ResourceActionsUtil.getPortletBaseResource(rootPortletId);
6948 primaryKey = String.valueOf(groupId);
6949 }
6950
6951 if (Validator.isNull(name)) {
6952 return;
6953 }
6954
6955 int count =
6956 ResourcePermissionLocalServiceUtil.getResourcePermissionsCount(
6957 companyId, name, ResourceConstants.SCOPE_INDIVIDUAL,
6958 primaryKey);
6959
6960 if (count > 0) {
6961 return;
6962 }
6963
6964 boolean addGuestPermissions = true;
6965
6966 if (portletActions) {
6967 Group layoutGroup = layout.getGroup();
6968
6969 if (layout.isPrivateLayout() && !layoutGroup.isLayoutPrototype()) {
6970 addGuestPermissions = false;
6971 }
6972 }
6973
6974 ResourceLocalServiceUtil.addResources(
6975 companyId, groupId, 0, name, primaryKey, portletActions, true,
6976 addGuestPermissions);
6977 }
6978
6979 protected String buildI18NPath(Locale locale) {
6980 String languageId = LocaleUtil.toLanguageId(locale);
6981
6982 if (Validator.isNull(languageId)) {
6983 return null;
6984 }
6985
6986 if (LanguageUtil.isDuplicateLanguageCode(locale.getLanguage())) {
6987 Locale priorityLocale = LanguageUtil.getLocale(
6988 locale.getLanguage());
6989
6990 if (locale.equals(priorityLocale)) {
6991 languageId = locale.getLanguage();
6992 }
6993 }
6994 else {
6995 languageId = locale.getLanguage();
6996 }
6997
6998 return StringPool.SLASH.concat(languageId);
6999 }
7000
7001 protected long doGetPlidFromPortletId(
7002 long groupId, boolean privateLayout, String portletId)
7003 throws PortalException, SystemException {
7004
7005 long scopeGroupId = groupId;
7006
7007 try {
7008 Group group = GroupLocalServiceUtil.getGroup(groupId);
7009
7010 if (group.isLayout()) {
7011 Layout scopeLayout = LayoutLocalServiceUtil.getLayout(
7012 group.getClassPK());
7013
7014 groupId = scopeLayout.getGroupId();
7015 }
7016 }
7017 catch (Exception e) {
7018 }
7019
7020 long plid = LayoutConstants.DEFAULT_PLID;
7021
7022 List<Layout> layouts = LayoutLocalServiceUtil.getLayouts(
7023 groupId, privateLayout, LayoutConstants.TYPE_PORTLET);
7024
7025 for (Layout layout : layouts) {
7026 LayoutTypePortlet layoutTypePortlet =
7027 (LayoutTypePortlet)layout.getLayoutType();
7028
7029 if (layoutTypePortlet.hasPortletId(portletId, true)) {
7030 if (getScopeGroupId(layout, portletId) == scopeGroupId) {
7031 plid = layout.getPlid();
7032
7033 break;
7034 }
7035 }
7036 }
7037
7038 return plid;
7039 }
7040
7041 protected List<Portlet> filterControlPanelPortlets(
7042 Set<Portlet> portlets, ThemeDisplay themeDisplay) {
7043
7044 List<Portlet> filteredPortlets = new ArrayList<Portlet>(portlets);
7045
7046 Iterator<Portlet> itr = filteredPortlets.iterator();
7047
7048 while (itr.hasNext()) {
7049 Portlet portlet = itr.next();
7050
7051 try {
7052 if (!portlet.isActive() || portlet.isInstanceable() ||
7053 !PortletPermissionUtil.hasControlPanelAccessPermission(
7054 themeDisplay.getPermissionChecker(),
7055 themeDisplay.getScopeGroupId(), portlet)) {
7056
7057 itr.remove();
7058 }
7059 }
7060 catch (Exception e) {
7061 _log.error(e, e);
7062
7063 itr.remove();
7064 }
7065 }
7066
7067 return filteredPortlets;
7068 }
7069
7070 protected Locale getAvailableLocale(long groupId, Locale locale) {
7071 if (Validator.isNull(locale.getCountry())) {
7072
7073
7074
7075 locale = LanguageUtil.getLocale(locale.getLanguage());
7076 }
7077
7078 if (!LanguageUtil.isAvailableLocale(groupId, locale)) {
7079 return null;
7080 }
7081
7082 return locale;
7083 }
7084
7085 protected String getCanonicalDomain(
7086 boolean canonicalURL, String virtualHostname, String portalDomain) {
7087
7088 if (!canonicalURL || Validator.isBlank(portalDomain)) {
7089 return virtualHostname;
7090 }
7091
7092 int pos = portalDomain.indexOf(CharPool.COLON);
7093
7094 if (pos != -1) {
7095 portalDomain = portalDomain.substring(0, pos);
7096 }
7097
7098 if (!StringUtil.equalsIgnoreCase(portalDomain, _LOCALHOST) &&
7099 StringUtil.equalsIgnoreCase(virtualHostname, _LOCALHOST)) {
7100
7101 virtualHostname = portalDomain;
7102 }
7103
7104 return virtualHostname;
7105 }
7106
7107 protected Map<String, List<Portlet>> getCategoriesMap(
7108 HttpServletRequest request, String attributeName,
7109 String[] categories)
7110 throws SystemException {
7111
7112 Map<String, List<Portlet>> categoriesMap =
7113 (Map<String, List<Portlet>>)request.getAttribute(attributeName);
7114
7115 if (categoriesMap != null) {
7116 return categoriesMap;
7117 }
7118
7119 ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
7120 WebKeys.THEME_DISPLAY);
7121
7122 categoriesMap = new LinkedHashMap<String, List<Portlet>>();
7123
7124 for (String category : categories) {
7125 List<Portlet> portlets = getControlPanelPortlets(
7126 category, themeDisplay);
7127
7128 if (!portlets.isEmpty()) {
7129 categoriesMap.put(category, portlets);
7130 }
7131 }
7132
7133 request.setAttribute(attributeName, categoriesMap);
7134
7135 return categoriesMap;
7136 }
7137
7138 protected long getDefaultScopeGroupId(long companyId)
7139 throws PortalException, SystemException {
7140
7141 long doAsGroupId = 0;
7142
7143 Collection<Portlet> portlets = getControlPanelPortlets(
7144 companyId, PortletCategoryKeys.SITE_ADMINISTRATION);
7145
7146 List<Group> groups = GroupServiceUtil.getManageableSiteGroups(
7147 portlets, 1);
7148
7149 if (!groups.isEmpty()) {
7150 Group group = groups.get(0);
7151
7152 doAsGroupId = group.getGroupId();
7153 }
7154 else {
7155 Group guestGroup = GroupLocalServiceUtil.fetchGroup(
7156 companyId, GroupConstants.GUEST);
7157
7158 if (guestGroup != null) {
7159 doAsGroupId = guestGroup.getGroupId();
7160 }
7161 }
7162
7163 return doAsGroupId;
7164 }
7165
7166 protected long getDoAsUserId(
7167 HttpServletRequest request, String doAsUserIdString,
7168 boolean alwaysAllowDoAsUser)
7169 throws Exception {
7170
7171 if (Validator.isNull(doAsUserIdString)) {
7172 return 0;
7173 }
7174
7175 long doAsUserId = 0;
7176
7177 try {
7178 Company company = getCompany(request);
7179
7180 doAsUserId = GetterUtil.getLong(
7181 Encryptor.decrypt(company.getKeyObj(), doAsUserIdString));
7182 }
7183 catch (Exception e) {
7184 if (_log.isWarnEnabled()) {
7185 _log.warn(
7186 "Unable to impersonate " + doAsUserIdString +
7187 " because the string cannot be decrypted");
7188 }
7189
7190 return 0;
7191 }
7192
7193 if (_log.isDebugEnabled()) {
7194 if (alwaysAllowDoAsUser) {
7195 _log.debug(
7196 "doAsUserId path or Struts action is always allowed");
7197 }
7198 else {
7199 _log.debug(
7200 "doAsUserId path is Struts action not always allowed");
7201 }
7202 }
7203
7204 if (alwaysAllowDoAsUser) {
7205 request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
7206
7207 return doAsUserId;
7208 }
7209
7210 HttpSession session = request.getSession();
7211
7212 Long realUserIdObj = (Long)session.getAttribute(WebKeys.USER_ID);
7213
7214 if (realUserIdObj == null) {
7215 return 0;
7216 }
7217
7218 User doAsUser = UserLocalServiceUtil.getUserById(doAsUserId);
7219
7220 long[] organizationIds = doAsUser.getOrganizationIds();
7221
7222 User realUser = UserLocalServiceUtil.getUserById(
7223 realUserIdObj.longValue());
7224
7225 PermissionChecker permissionChecker =
7226 PermissionCheckerFactoryUtil.create(realUser);
7227
7228 if (doAsUser.isDefaultUser() ||
7229 UserPermissionUtil.contains(
7230 permissionChecker, doAsUserId, organizationIds,
7231 ActionKeys.IMPERSONATE)) {
7232
7233 request.setAttribute(WebKeys.USER_ID, new Long(doAsUserId));
7234
7235 return doAsUserId;
7236 }
7237
7238 _log.error(
7239 "User " + realUserIdObj + " does not have the permission to " +
7240 "impersonate " + doAsUserId);
7241
7242 return 0;
7243 }
7244
7245 protected String getGroupFriendlyURL(
7246 Group group, boolean privateLayoutSet, ThemeDisplay themeDisplay,
7247 boolean canonicalURL)
7248 throws PortalException, SystemException {
7249
7250 LayoutSet layoutSet = LayoutSetLocalServiceUtil.getLayoutSet(
7251 group.getGroupId(), privateLayoutSet);
7252
7253 String portalURL = themeDisplay.getPortalURL();
7254
7255 if (canonicalURL || !themeDisplay.getServerName().equals(_LOCALHOST)) {
7256 String virtualHostname = layoutSet.getVirtualHostname();
7257
7258 if (Validator.isNull(virtualHostname) &&
7259 Validator.isNotNull(
7260 PropsValues.VIRTUAL_HOSTS_DEFAULT_SITE_NAME) &&
7261 !layoutSet.isPrivateLayout()) {
7262
7263 try {
7264 Group defaultGroup = GroupLocalServiceUtil.getGroup(
7265 themeDisplay.getCompanyId(),
7266 PropsValues.VIRTUAL_HOSTS_DEFAULT_SITE_NAME);
7267
7268 if (layoutSet.getGroupId() == defaultGroup.getGroupId()) {
7269 Company company = themeDisplay.getCompany();
7270
7271 virtualHostname = company.getVirtualHostname();
7272 }
7273 }
7274 catch (Exception e) {
7275 _log.error(e, e);
7276 }
7277 }
7278
7279 String portalDomain = HttpUtil.getDomain(portalURL);
7280
7281 if (Validator.isNotNull(virtualHostname) &&
7282 (canonicalURL ||
7283 !StringUtil.equalsIgnoreCase(virtualHostname, _LOCALHOST))) {
7284
7285 virtualHostname = getCanonicalDomain(
7286 canonicalURL, virtualHostname, portalDomain);
7287
7288 virtualHostname = getPortalURL(
7289 virtualHostname, themeDisplay.getServerPort(),
7290 themeDisplay.isSecure());
7291
7292 if (canonicalURL || virtualHostname.contains(portalDomain)) {
7293 String path = StringPool.BLANK;
7294
7295 if (themeDisplay.isWidget()) {
7296 path = PropsValues.WIDGET_SERVLET_MAPPING;
7297 }
7298
7299 if (themeDisplay.isI18n() && !canonicalURL) {
7300 path = themeDisplay.getI18nPath();
7301 }
7302
7303 return virtualHostname.concat(_pathContext).concat(path);
7304 }
7305 }
7306 else {
7307 LayoutSet curLayoutSet = LayoutSetLocalServiceUtil.getLayoutSet(
7308 themeDisplay.getSiteGroupId(), privateLayoutSet);
7309
7310 if (canonicalURL ||
7311 ((layoutSet.getLayoutSetId() !=
7312 curLayoutSet.getLayoutSetId()) &&
7313 (group.getClassPK() != themeDisplay.getUserId()))) {
7314
7315 if (group.isControlPanel()) {
7316 virtualHostname = themeDisplay.getServerName();
7317
7318 if (Validator.isNull(virtualHostname) ||
7319 StringUtil.equalsIgnoreCase(
7320 virtualHostname, _LOCALHOST)) {
7321
7322 virtualHostname = curLayoutSet.getVirtualHostname();
7323 }
7324 }
7325
7326 if (Validator.isNull(virtualHostname) ||
7327 StringUtil.equalsIgnoreCase(
7328 virtualHostname, _LOCALHOST)) {
7329
7330 Company company = themeDisplay.getCompany();
7331
7332 virtualHostname = company.getVirtualHostname();
7333 }
7334
7335 if (canonicalURL ||
7336 !StringUtil.equalsIgnoreCase(
7337 virtualHostname, _LOCALHOST)) {
7338
7339 virtualHostname = getCanonicalDomain(
7340 canonicalURL, virtualHostname, portalDomain);
7341
7342 portalURL = getPortalURL(
7343 virtualHostname, themeDisplay.getServerPort(),
7344 themeDisplay.isSecure());
7345 }
7346 }
7347 }
7348 }
7349
7350 String friendlyURL = null;
7351
7352 if (privateLayoutSet) {
7353 if (group.isUser()) {
7354 friendlyURL = _PRIVATE_USER_SERVLET_MAPPING;
7355 }
7356 else {
7357 friendlyURL = _PRIVATE_GROUP_SERVLET_MAPPING;
7358 }
7359 }
7360 else {
7361 friendlyURL = _PUBLIC_GROUP_SERVLET_MAPPING;
7362 }
7363
7364 StringBundler sb = new StringBundler(6);
7365
7366 sb.append(portalURL);
7367 sb.append(_pathContext);
7368
7369 if (themeDisplay.isI18n() && !canonicalURL) {
7370 sb.append(themeDisplay.getI18nPath());
7371 }
7372
7373 if (themeDisplay.isWidget()) {
7374 sb.append(PropsValues.WIDGET_SERVLET_MAPPING);
7375 }
7376
7377 sb.append(friendlyURL);
7378 sb.append(group.getFriendlyURL());
7379
7380 return sb.toString();
7381 }
7382
7383 protected String getPortletParam(HttpServletRequest request, String name) {
7384 String portletId = ParamUtil.getString(request, "p_p_id");
7385
7386 if (Validator.isNull(portletId)) {
7387 return StringPool.BLANK;
7388 }
7389
7390 String value = null;
7391
7392 int valueCount = 0;
7393
7394 String keyName = StringPool.UNDERLINE.concat(name);
7395
7396 Map<String, String[]> parameterMap = request.getParameterMap();
7397
7398 for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
7399 String parameterName = entry.getKey();
7400
7401 int pos = parameterName.indexOf(keyName);
7402
7403 if (pos == -1) {
7404 continue;
7405 }
7406
7407 valueCount++;
7408
7409
7410
7411 if (valueCount > 1) {
7412 return StringPool.BLANK;
7413 }
7414
7415 String[] parameterValues = entry.getValue();
7416
7417 if (ArrayUtil.isEmpty(parameterValues) ||
7418 Validator.isNull(parameterValues[0])) {
7419
7420 continue;
7421 }
7422
7423
7424
7425 String portletId1 = parameterName.substring(1, pos);
7426
7427 if (portletId.equals(portletId1)) {
7428 value = parameterValues[0];
7429 }
7430 }
7431
7432 if (value == null) {
7433 value = StringPool.BLANK;
7434 }
7435
7436 return value;
7437 }
7438
7439 protected String getServletURL(
7440 Portlet portlet, String servletPath, ThemeDisplay themeDisplay)
7441 throws PortalException, SystemException {
7442
7443 Layout layout = themeDisplay.getLayout();
7444
7445 StringBundler sb = new StringBundler();
7446
7447 sb.append(themeDisplay.getPortalURL());
7448
7449 if (Validator.isNotNull(_pathContext)) {
7450 sb.append(_pathContext);
7451 }
7452
7453 if (themeDisplay.isI18n()) {
7454 sb.append(themeDisplay.getI18nPath());
7455 }
7456
7457 sb.append(servletPath);
7458
7459 Group group = layout.getGroup();
7460
7461 if (layout.isPrivateLayout()) {
7462 if (group.isUser()) {
7463 sb.append(_PRIVATE_USER_SERVLET_MAPPING);
7464 }
7465 else {
7466 sb.append(_PRIVATE_GROUP_SERVLET_MAPPING);
7467 }
7468 }
7469 else {
7470 sb.append(_PUBLIC_GROUP_SERVLET_MAPPING);
7471 }
7472
7473 sb.append(group.getFriendlyURL());
7474 sb.append(layout.getFriendlyURL(themeDisplay.getLocale()));
7475
7476 sb.append(FRIENDLY_URL_SEPARATOR);
7477
7478 FriendlyURLMapper friendlyURLMapper =
7479 portlet.getFriendlyURLMapperInstance();
7480
7481 if ((friendlyURLMapper != null) && !portlet.isInstanceable()) {
7482 sb.append(friendlyURLMapper.getMapping());
7483 }
7484 else {
7485 sb.append(portlet.getPortletId());
7486 }
7487
7488 return sb.toString();
7489 }
7490
7491 protected boolean isAlwaysAllowDoAsUser(HttpServletRequest request)
7492 throws Exception {
7493
7494 String ticketKey = ParamUtil.getString(request, "ticketKey");
7495
7496 if (Validator.isNull(ticketKey)) {
7497 return false;
7498 }
7499
7500 Ticket ticket = TicketLocalServiceUtil.fetchTicket(ticketKey);
7501
7502 if ((ticket == null) ||
7503 (ticket.getType() != TicketConstants.TYPE_IMPERSONATE)) {
7504
7505 return false;
7506 }
7507
7508 String className = ticket.getClassName();
7509
7510 if (!className.equals(User.class.getName())) {
7511 return false;
7512 }
7513
7514 long doAsUserId = 0;
7515
7516 try {
7517 Company company = getCompany(request);
7518
7519 String doAsUserIdString = ParamUtil.getString(
7520 request, "doAsUserId");
7521
7522 if (Validator.isNotNull(doAsUserIdString)) {
7523 doAsUserId = GetterUtil.getLong(
7524 Encryptor.decrypt(company.getKeyObj(), doAsUserIdString));
7525 }
7526 }
7527 catch (Exception e) {
7528 return false;
7529 }
7530
7531 if (ticket.getClassPK() != doAsUserId) {
7532 return false;
7533 }
7534
7535 if (ticket.isExpired()) {
7536 TicketLocalServiceUtil.deleteTicket(ticket);
7537
7538 return false;
7539 }
7540
7541 Date expirationDate = new Date(
7542 System.currentTimeMillis() +
7543 PropsValues.SESSION_TIMEOUT * Time.MINUTE);
7544
7545 ticket.setExpirationDate(expirationDate);
7546
7547 TicketLocalServiceUtil.updateTicket(ticket);
7548
7549 return true;
7550 }
7551
7552
7555 protected boolean isPanelSelectedPortlet(
7556 ThemeDisplay themeDisplay, String portletId) {
7557
7558 Layout layout = themeDisplay.getLayout();
7559
7560 String panelSelectedPortlets = layout.getTypeSettingsProperty(
7561 "panelSelectedPortlets");
7562
7563 if (Validator.isNotNull(panelSelectedPortlets)) {
7564 String[] panelSelectedPortletsArray = StringUtil.split(
7565 panelSelectedPortlets);
7566
7567 return ArrayUtil.contains(panelSelectedPortletsArray, portletId);
7568 }
7569
7570 return false;
7571 }
7572
7573 protected void notifyPortalPortEventListeners(int portalPort) {
7574 for (PortalPortEventListener portalPortEventListener :
7575 _portalPortEventListeners) {
7576
7577 portalPortEventListener.portalPortConfigured(portalPort);
7578 }
7579 }
7580
7581 protected String removeRedirectParameter(String url) {
7582 String queryString = HttpUtil.getQueryString(url);
7583
7584 Map<String, String[]> parameterMap = HttpUtil.getParameterMap(
7585 queryString);
7586
7587 for (String parameter : parameterMap.keySet()) {
7588 if (parameter.endsWith("redirect")) {
7589 url = HttpUtil.removeParameter(url, parameter);
7590 }
7591 }
7592
7593 return url;
7594 }
7595
7596 protected void resetThemeDisplayI18n(
7597 ThemeDisplay themeDisplay, String languageId, String path) {
7598
7599 themeDisplay.setI18nLanguageId(languageId);
7600 themeDisplay.setI18nPath(path);
7601 }
7602
7603 protected void setLocale(
7604 HttpServletRequest request, HttpServletResponse response,
7605 Locale locale) {
7606
7607 HttpSession session = request.getSession();
7608
7609 session.setAttribute(Globals.LOCALE_KEY, locale);
7610
7611 LanguageUtil.updateCookie(request, response, locale);
7612 }
7613
7614 protected void setThemeDisplayI18n(
7615 ThemeDisplay themeDisplay, Locale locale) {
7616
7617 String i18nLanguageId = null;
7618 String i18nPath = null;
7619
7620 if ((I18nFilter.getLanguageIds().contains(locale.toString()) &&
7621 ((PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 1) &&
7622 !locale.equals(LocaleUtil.getDefault()))) ||
7623 (PropsValues.LOCALE_PREPEND_FRIENDLY_URL_STYLE == 2)) {
7624
7625 i18nLanguageId = locale.toString();
7626 i18nPath = buildI18NPath(locale);
7627 }
7628
7629 themeDisplay.setI18nLanguageId(i18nLanguageId);
7630 themeDisplay.setI18nPath(i18nPath);
7631 }
7632
7633 private static final String _J_SECURITY_CHECK = "j_security_check";
7634
7635 private static final String _JSESSIONID = ";jsessionid=";
7636
7637 private static final String _LOCALHOST = "localhost";
7638
7639 private static final String _PRIVATE_GROUP_SERVLET_MAPPING =
7640 PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_GROUP_SERVLET_MAPPING;
7641
7642 private static final String _PRIVATE_USER_SERVLET_MAPPING =
7643 PropsValues.LAYOUT_FRIENDLY_URL_PRIVATE_USER_SERVLET_MAPPING;
7644
7645 private static final String _PUBLIC_GROUP_SERVLET_MAPPING =
7646 PropsValues.LAYOUT_FRIENDLY_URL_PUBLIC_SERVLET_MAPPING;
7647
7648 private static Log _log = LogFactoryUtil.getLog(PortalImpl.class);
7649
7650 private static Log _logWebServerServlet = LogFactoryUtil.getLog(
7651 WebServerServlet.class);
7652
7653 private static Map<Long, String> _cdnHostHttpMap =
7654 new ConcurrentHashMap<Long, String>();
7655 private static Map<Long, String> _cdnHostHttpsMap =
7656 new ConcurrentHashMap<Long, String>();
7657 private static MethodHandler _resetCDNHostsMethodHandler =
7658 new MethodHandler(new MethodKey(PortalUtil.class, "resetCDNHosts"));
7659 private static Date _upTime = new Date();
7660
7661 private String[] _allSystemGroups;
7662 private String[] _allSystemOrganizationRoles;
7663 private String[] _allSystemRoles;
7664 private String[] _allSystemSiteRoles;
7665 private Pattern _bannedResourceIdPattern = Pattern.compile(
7666 PropsValues.PORTLET_RESOURCE_ID_BANNED_PATHS_REGEXP,
7667 Pattern.CASE_INSENSITIVE);
7668 private String _computerAddress;
7669 private String _computerName;
7670 private String[] _customSqlKeys;
7671 private String[] _customSqlValues;
7672 private EditDiscussionAction _editDiscussionAction =
7673 new EditDiscussionAction();
7674 private String _pathContext;
7675 private String _pathFriendlyURLPrivateGroup;
7676 private String _pathFriendlyURLPrivateUser;
7677 private String _pathFriendlyURLPublic;
7678 private String _pathImage;
7679 private String _pathMain;
7680 private String _pathModule;
7681 private String _pathProxy;
7682 private Map<String, Long> _plidToPortletIdMap =
7683 new ConcurrentHashMap<String, Long>();
7684 private final AtomicInteger _portalPort = new AtomicInteger(-1);
7685 private List<PortalPortEventListener> _portalPortEventListeners =
7686 new ArrayList<PortalPortEventListener>();
7687 private Set<String> _reservedParams;
7688 private final AtomicInteger _securePortalPort = new AtomicInteger(-1);
7689 private final String _servletContextName;
7690 private String[] _sortedSystemGroups;
7691 private String[] _sortedSystemOrganizationRoles;
7692 private String[] _sortedSystemRoles;
7693 private String[] _sortedSystemSiteRoles;
7694
7695 }