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