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