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