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