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