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