001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet;
016    
017    import com.liferay.portal.kernel.cache.PortalCache;
018    import com.liferay.portal.kernel.cache.SingleVMPoolUtil;
019    import com.liferay.portal.kernel.exception.PortalException;
020    import com.liferay.portal.kernel.exception.SystemException;
021    import com.liferay.portal.kernel.io.unsync.UnsyncStringReader;
022    import com.liferay.portal.kernel.portlet.LiferayPortletMode;
023    import com.liferay.portal.kernel.security.pacl.DoPrivileged;
024    import com.liferay.portal.kernel.util.GetterUtil;
025    import com.liferay.portal.kernel.util.JavaConstants;
026    import com.liferay.portal.kernel.util.ParamUtil;
027    import com.liferay.portal.kernel.util.StringPool;
028    import com.liferay.portal.kernel.util.Validator;
029    import com.liferay.portal.model.Group;
030    import com.liferay.portal.model.Layout;
031    import com.liferay.portal.model.LayoutConstants;
032    import com.liferay.portal.model.LayoutTypePortlet;
033    import com.liferay.portal.model.Portlet;
034    import com.liferay.portal.model.PortletConstants;
035    import com.liferay.portal.model.PortletPreferencesIds;
036    import com.liferay.portal.security.auth.PrincipalException;
037    import com.liferay.portal.security.permission.ActionKeys;
038    import com.liferay.portal.security.permission.PermissionChecker;
039    import com.liferay.portal.security.permission.PermissionThreadLocal;
040    import com.liferay.portal.service.GroupLocalServiceUtil;
041    import com.liferay.portal.service.PortalPreferencesLocalServiceUtil;
042    import com.liferay.portal.service.PortletLocalServiceUtil;
043    import com.liferay.portal.service.PortletPreferencesLocalServiceUtil;
044    import com.liferay.portal.service.UserLocalServiceUtil;
045    import com.liferay.portal.service.permission.LayoutPermissionUtil;
046    import com.liferay.portal.service.permission.PortletPermissionUtil;
047    import com.liferay.portal.theme.ThemeDisplay;
048    import com.liferay.portal.util.PortalUtil;
049    import com.liferay.portal.util.PortletKeys;
050    import com.liferay.portal.util.WebKeys;
051    import com.liferay.portal.xml.StAXReaderUtil;
052    import com.liferay.portlet.portletconfiguration.util.ConfigurationPortletRequest;
053    
054    import java.util.ArrayList;
055    import java.util.Collections;
056    import java.util.HashMap;
057    import java.util.List;
058    import java.util.Map;
059    
060    import javax.portlet.PortletPreferences;
061    import javax.portlet.PortletRequest;
062    import javax.portlet.PreferencesValidator;
063    import javax.portlet.filter.PortletRequestWrapper;
064    
065    import javax.servlet.http.HttpServletRequest;
066    import javax.servlet.http.HttpSession;
067    
068    import javax.xml.stream.XMLEventReader;
069    import javax.xml.stream.XMLInputFactory;
070    import javax.xml.stream.XMLStreamException;
071    import javax.xml.stream.events.EndElement;
072    import javax.xml.stream.events.StartElement;
073    import javax.xml.stream.events.XMLEvent;
074    
075    /**
076     * @author Brian Wing Shun Chan
077     * @author Alexander Chow
078     * @author Minhchau Dang
079     * @author Raymond Aug??
080     */
081    @DoPrivileged
082    public class PortletPreferencesFactoryImpl
083            implements PortletPreferencesFactory {
084    
085            @Override
086            public void checkControlPanelPortletPreferences(
087                            ThemeDisplay themeDisplay, Portlet portlet)
088                    throws PortalException {
089    
090                    Layout layout = themeDisplay.getLayout();
091    
092                    Group group = layout.getGroup();
093    
094                    if (!group.isControlPanel()) {
095                            return;
096                    }
097    
098                    String portletId = portlet.getPortletId();
099    
100                    boolean hasControlPanelAccessPermission =
101                            PortletPermissionUtil.hasControlPanelAccessPermission(
102                                    themeDisplay.getPermissionChecker(),
103                                    themeDisplay.getScopeGroupId(), portletId);
104    
105                    if (!hasControlPanelAccessPermission) {
106                            return;
107                    }
108    
109                    PortletPreferences portletSetup = getStrictLayoutPortletSetup(
110                            layout, portletId);
111    
112                    if (portletSetup instanceof StrictPortletPreferencesImpl) {
113                            getLayoutPortletSetup(layout, portletId);
114                    }
115    
116                    if (portlet.isInstanceable()) {
117                            return;
118                    }
119    
120                    PortletPreferencesIds portletPreferencesIds = getPortletPreferencesIds(
121                            themeDisplay.getScopeGroupId(), themeDisplay.getUserId(), layout,
122                            portletId, false);
123    
124                    PortletPreferences portletPreferences =
125                            PortletPreferencesLocalServiceUtil.fetchPreferences(
126                                    portletPreferencesIds);
127    
128                    if (portletPreferences != null) {
129                            return;
130                    }
131    
132                    PortletPreferencesLocalServiceUtil.getPreferences(
133                            portletPreferencesIds);
134            }
135    
136            @Override
137            public PortletPreferences fromDefaultXML(String xml) {
138                    Map<String, Preference> preferencesMap = toPreferencesMap(xml);
139    
140                    return new PortletPreferencesImpl(xml, preferencesMap);
141            }
142    
143            @Override
144            public PortalPreferencesImpl fromXML(
145                    long ownerId, int ownerType, String xml) {
146    
147                    try {
148                            Map<String, Preference> preferencesMap = toPreferencesMap(xml);
149    
150                            return new PortalPreferencesImpl(
151                                    ownerId, ownerType, xml, preferencesMap, false);
152                    }
153                    catch (SystemException se) {
154                            throw se;
155                    }
156            }
157    
158            @Override
159            public PortletPreferencesImpl fromXML(
160                    long companyId, long ownerId, int ownerType, long plid,
161                    String portletId, String xml) {
162    
163                    try {
164                            Map<String, Preference> preferencesMap = toPreferencesMap(xml);
165    
166                            return new PortletPreferencesImpl(
167                                    companyId, ownerId, ownerType, plid, portletId, xml,
168                                    preferencesMap);
169                    }
170                    catch (SystemException se) {
171                            throw se;
172                    }
173            }
174    
175            /**
176             * @deprecated As of 6.2.0, replaced by {@link #fromXML(long, int, String)}
177             */
178            @Deprecated
179            @Override
180            public PortalPreferences fromXML(
181                    long companyId, long ownerId, int ownerType, String xml) {
182    
183                    return fromXML(ownerId, ownerType, xml);
184            }
185    
186            @Override
187            public PortletPreferences getLayoutPortletSetup(
188                    Layout layout, String portletId) {
189    
190                    long ownerId = PortletKeys.PREFS_OWNER_ID_DEFAULT;
191                    int ownerType = PortletKeys.PREFS_OWNER_TYPE_LAYOUT;
192    
193                    if (PortletConstants.hasUserId(portletId)) {
194                            ownerId = PortletConstants.getUserId(portletId);
195                            ownerType = PortletKeys.PREFS_OWNER_TYPE_USER;
196                    }
197    
198                    return PortletPreferencesLocalServiceUtil.getPreferences(
199                            layout.getCompanyId(), ownerId, ownerType, layout.getPlid(),
200                            portletId);
201            }
202    
203            @Override
204            public PortalPreferences getPortalPreferences(HttpServletRequest request) {
205                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
206                            WebKeys.THEME_DISPLAY);
207    
208                    return getPortalPreferences(
209                            request.getSession(), themeDisplay.getUserId(),
210                            themeDisplay.isSignedIn());
211            }
212    
213            @Override
214            public PortalPreferences getPortalPreferences(
215                    HttpSession session, long userId, boolean signedIn) {
216    
217                    long ownerId = userId;
218                    int ownerType = PortletKeys.PREFS_OWNER_TYPE_USER;
219    
220                    PortalPreferences portalPreferences = null;
221    
222                    if (signedIn) {
223                            PortalPreferencesWrapper portalPreferencesWrapper =
224                                    PortalPreferencesWrapperCacheUtil.get(ownerId, ownerType);
225    
226                            if (portalPreferencesWrapper == null) {
227                                    portalPreferencesWrapper =
228                                            (PortalPreferencesWrapper)
229                                                    PortalPreferencesLocalServiceUtil.getPreferences(
230                                                            ownerId, ownerType);
231    
232                                    portalPreferences =
233                                            portalPreferencesWrapper.getPortalPreferencesImpl();
234                            }
235                            else {
236                                    PortalPreferencesImpl portalPreferencesImpl =
237                                            portalPreferencesWrapper.getPortalPreferencesImpl();
238    
239                                    portalPreferences = portalPreferencesImpl.clone();
240                            }
241                    }
242                    else {
243                            if (session != null) {
244                                    portalPreferences = (PortalPreferences)session.getAttribute(
245                                            WebKeys.PORTAL_PREFERENCES);
246                            }
247    
248                            if (portalPreferences == null) {
249                                    PortalPreferencesWrapper portalPreferencesWrapper =
250                                            PortalPreferencesWrapperCacheUtil.get(ownerId, ownerType);
251    
252                                    if (portalPreferencesWrapper == null) {
253                                            portalPreferencesWrapper =
254                                                    (PortalPreferencesWrapper)
255                                                            PortalPreferencesLocalServiceUtil.getPreferences(
256                                                                    ownerId, ownerType);
257    
258                                            portalPreferences =
259                                                    portalPreferencesWrapper.getPortalPreferencesImpl();
260                                    }
261                                    else {
262                                            PortalPreferencesImpl portalPreferencesImpl =
263                                                    portalPreferencesWrapper.getPortalPreferencesImpl();
264    
265                                            portalPreferences = portalPreferencesImpl.clone();
266                                    }
267    
268                                    if (session != null) {
269                                            session.setAttribute(
270                                                    WebKeys.PORTAL_PREFERENCES, portalPreferences);
271                                    }
272                            }
273                    }
274    
275                    portalPreferences.setSignedIn(signedIn);
276                    portalPreferences.setUserId(userId);
277    
278                    return portalPreferences;
279            }
280    
281            /**
282             * @deprecated As of 6.2.0, replaced by {@link
283             *             #getPortalPreferences(HttpSession, long, boolean)}
284             */
285            @Deprecated
286            @Override
287            public PortalPreferences getPortalPreferences(
288                    HttpSession session, long companyId, long userId, boolean signedIn) {
289    
290                    return getPortalPreferences(session, userId, signedIn);
291            }
292    
293            @Override
294            public PortalPreferences getPortalPreferences(
295                    long userId, boolean signedIn) {
296    
297                    return getPortalPreferences(null, userId, signedIn);
298            }
299    
300            /**
301             * @deprecated As of 6.2.0, replaced by {@link #getPortalPreferences(long,
302             *             boolean)}
303             */
304            @Deprecated
305            @Override
306            public PortalPreferences getPortalPreferences(
307                    long companyId, long userId, boolean signedIn) {
308    
309                    return getPortalPreferences(userId, signedIn);
310            }
311    
312            @Override
313            public PortalPreferences getPortalPreferences(
314                    PortletRequest portletRequest) {
315    
316                    HttpServletRequest request = PortalUtil.getHttpServletRequest(
317                            portletRequest);
318    
319                    return getPortalPreferences(request);
320            }
321    
322            @Override
323            public PortletPreferences getPortletPreferences(
324                            HttpServletRequest request, String portletId)
325                    throws PortalException {
326    
327                    PortletPreferencesIds portletPreferencesIds = getPortletPreferencesIds(
328                            request, portletId);
329    
330                    return PortletPreferencesLocalServiceUtil.getPreferences(
331                            portletPreferencesIds);
332            }
333    
334            @Override
335            public PortletPreferencesIds getPortletPreferencesIds(
336                            HttpServletRequest request, Layout layout, String portletId)
337                    throws PortalException {
338    
339                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
340                            WebKeys.THEME_DISPLAY);
341    
342                    long siteGroupId = themeDisplay.getSiteGroupId();
343                    long userId = PortalUtil.getUserId(request);
344                    LayoutTypePortlet layoutTypePortlet =
345                            themeDisplay.getLayoutTypePortlet();
346    
347                    boolean modeEditGuest = false;
348    
349                    String portletMode = ParamUtil.getString(request, "p_p_mode");
350    
351                    if (portletMode.equals(LiferayPortletMode.EDIT_GUEST.toString()) ||
352                            ((layoutTypePortlet != null) &&
353                             layoutTypePortlet.hasModeEditGuestPortletId(portletId))) {
354    
355                            modeEditGuest = true;
356                    }
357    
358                    return getPortletPreferencesIds(
359                            siteGroupId, userId, layout, portletId, modeEditGuest);
360            }
361    
362            @Override
363            public PortletPreferencesIds getPortletPreferencesIds(
364                            HttpServletRequest request, String portletId)
365                    throws PortalException {
366    
367                    Layout layout = (Layout)request.getAttribute(WebKeys.LAYOUT);
368    
369                    return getPortletPreferencesIds(request, layout, portletId);
370            }
371    
372            @Override
373            public PortletPreferencesIds getPortletPreferencesIds(
374                            long siteGroupId, long userId, Layout layout, String portletId,
375                            boolean modeEditGuest)
376                    throws PortalException {
377    
378                    PermissionChecker permissionChecker =
379                            PermissionThreadLocal.getPermissionChecker();
380    
381                    String originalPortletId = portletId;
382    
383                    Portlet portlet = PortletLocalServiceUtil.getPortletById(
384                            layout.getCompanyId(), portletId);
385    
386                    long ownerId = 0;
387                    int ownerType = 0;
388                    long plid = 0;
389    
390                    if (modeEditGuest) {
391                            boolean hasUpdateLayoutPermission = LayoutPermissionUtil.contains(
392                                    permissionChecker, layout, ActionKeys.UPDATE);
393    
394                            if (!layout.isPrivateLayout() && hasUpdateLayoutPermission) {
395                            }
396                            else {
397    
398                                    // Only users with the correct permissions can update guest
399                                    // preferences
400    
401                                    throw new PrincipalException();
402                            }
403                    }
404    
405                    if (PortletConstants.hasUserId(originalPortletId) &&
406                            (PortletConstants.getUserId(originalPortletId) == userId)) {
407    
408                            ownerId = userId;
409                            ownerType = PortletKeys.PREFS_OWNER_TYPE_USER;
410                            plid = layout.getPlid();
411                    }
412                    else if (portlet.isPreferencesCompanyWide()) {
413                            ownerId = layout.getCompanyId();
414                            ownerType = PortletKeys.PREFS_OWNER_TYPE_COMPANY;
415                            plid = PortletKeys.PREFS_PLID_SHARED;
416                            portletId = PortletConstants.getRootPortletId(portletId);
417                    }
418                    else {
419                            if (portlet.isPreferencesUniquePerLayout()) {
420                                    ownerId = PortletKeys.PREFS_OWNER_ID_DEFAULT;
421                                    ownerType = PortletKeys.PREFS_OWNER_TYPE_LAYOUT;
422                                    plid = layout.getPlid();
423    
424                                    if (portlet.isPreferencesOwnedByGroup()) {
425                                    }
426                                    else {
427                                            if ((userId <= 0) || modeEditGuest) {
428                                                    userId = UserLocalServiceUtil.getDefaultUserId(
429                                                            layout.getCompanyId());
430                                            }
431    
432                                            ownerId = userId;
433                                            ownerType = PortletKeys.PREFS_OWNER_TYPE_USER;
434                                    }
435                            }
436                            else {
437                                    plid = PortletKeys.PREFS_PLID_SHARED;
438    
439                                    if (portlet.isPreferencesOwnedByGroup()) {
440                                            ownerId = siteGroupId;
441                                            ownerType = PortletKeys.PREFS_OWNER_TYPE_GROUP;
442                                            portletId = PortletConstants.getRootPortletId(portletId);
443                                    }
444                                    else {
445                                            if ((userId <= 0) || modeEditGuest) {
446                                                    userId = UserLocalServiceUtil.getDefaultUserId(
447                                                            layout.getCompanyId());
448                                            }
449    
450                                            ownerId = userId;
451                                            ownerType = PortletKeys.PREFS_OWNER_TYPE_USER;
452                                    }
453                            }
454                    }
455    
456                    return new PortletPreferencesIds(
457                            layout.getCompanyId(), ownerId, ownerType, plid, portletId);
458            }
459    
460            @Override
461            public PortletPreferences getPortletSetup(
462                    HttpServletRequest request, String portletId) {
463    
464                    return getPortletSetup(request, portletId, null);
465            }
466    
467            @Override
468            public PortletPreferences getPortletSetup(
469                    HttpServletRequest request, String portletId,
470                    String defaultPreferences) {
471    
472                    PortletRequest portletRequest = (PortletRequest)request.getAttribute(
473                            JavaConstants.JAVAX_PORTLET_REQUEST);
474    
475                    if (portletRequest instanceof ConfigurationPortletRequest) {
476                            PortletRequestWrapper portletRequestWrapper =
477                                    (PortletRequestWrapper)portletRequest;
478    
479                            return portletRequestWrapper.getPreferences();
480                    }
481    
482                    ThemeDisplay themeDisplay = (ThemeDisplay)request.getAttribute(
483                            WebKeys.THEME_DISPLAY);
484    
485                    return getPortletSetup(
486                            themeDisplay.getSiteGroupId(), themeDisplay.getLayout(), portletId,
487                            defaultPreferences);
488            }
489    
490            @Override
491            public PortletPreferences getPortletSetup(
492                    Layout layout, String portletId, String defaultPreferences) {
493    
494                    return getPortletSetup(
495                            LayoutConstants.DEFAULT_PLID, layout, portletId,
496                            defaultPreferences);
497            }
498    
499            @Override
500            public PortletPreferences getPortletSetup(
501                    long siteGroupId, Layout layout, String portletId,
502                    String defaultPreferences) {
503    
504                    return getPortletSetup(
505                            siteGroupId, layout, portletId, defaultPreferences, false);
506            }
507    
508            @Override
509            public PortletPreferences getPortletSetup(PortletRequest portletRequest) {
510                    String portletId = PortalUtil.getPortletId(portletRequest);
511    
512                    return getPortletSetup(portletRequest, portletId);
513            }
514    
515            @Override
516            public PortletPreferences getPortletSetup(
517                    PortletRequest portletRequest, String portletId) {
518    
519                    if (portletRequest instanceof ConfigurationPortletRequest) {
520                            PortletRequestWrapper portletRequestWrapper =
521                                    (PortletRequestWrapper)portletRequest;
522    
523                            return portletRequestWrapper.getPreferences();
524                    }
525    
526                    HttpServletRequest request = PortalUtil.getHttpServletRequest(
527                            portletRequest);
528    
529                    return getPortletSetup(request, portletId);
530            }
531    
532            @Override
533            public Map<Long, PortletPreferences> getPortletSetupMap(
534                    long companyId, long groupId, long ownerId, int ownerType,
535                    String portletId, boolean privateLayout) {
536    
537                    Map<Long, PortletPreferences> portletSetupMap =
538                            new HashMap<Long, PortletPreferences>();
539    
540                    List<com.liferay.portal.model.PortletPreferences>
541                            portletPreferencesList =
542                                    PortletPreferencesLocalServiceUtil.getPortletPreferences(
543                                            companyId, groupId, ownerId, ownerType, portletId,
544                                            privateLayout);
545    
546                    for (com.liferay.portal.model.PortletPreferences portletPreferences :
547                                    portletPreferencesList) {
548    
549                            PortletPreferences portletSetup =
550                                    PortletPreferencesLocalServiceUtil.getPreferences(
551                                            companyId, ownerId, ownerType, portletPreferences.getPlid(),
552                                            portletId);
553    
554                            portletSetupMap.put(portletPreferences.getPlid(), portletSetup);
555                    }
556    
557                    return portletSetupMap;
558            }
559    
560            @Override
561            public PortletPreferences getPreferences(HttpServletRequest request) {
562                    PortletRequest portletRequest = (PortletRequest)request.getAttribute(
563                            JavaConstants.JAVAX_PORTLET_REQUEST);
564    
565                    PortletPreferences portletPreferences = null;
566    
567                    if (portletRequest != null) {
568                            PortletPreferencesWrapper portletPreferencesWrapper =
569                                    (PortletPreferencesWrapper)portletRequest.getPreferences();
570    
571                            portletPreferences =
572                                    portletPreferencesWrapper.getPortletPreferencesImpl();
573                    }
574    
575                    return portletPreferences;
576            }
577    
578            @Override
579            public PreferencesValidator getPreferencesValidator(Portlet portlet) {
580                    return PortalUtil.getPreferencesValidator(portlet);
581            }
582    
583            @Override
584            public PortletPreferences getStrictLayoutPortletSetup(
585                    Layout layout, String portletId) {
586    
587                    long ownerId = PortletKeys.PREFS_OWNER_ID_DEFAULT;
588                    int ownerType = PortletKeys.PREFS_OWNER_TYPE_LAYOUT;
589    
590                    if (PortletConstants.hasUserId(portletId)) {
591                            ownerId = PortletConstants.getUserId(portletId);
592                            ownerType = PortletKeys.PREFS_OWNER_TYPE_USER;
593                    }
594    
595                    return PortletPreferencesLocalServiceUtil.getStrictPreferences(
596                            layout.getCompanyId(), ownerId, ownerType, layout.getPlid(),
597                            portletId);
598            }
599    
600            @Override
601            public PortletPreferences getStrictPortletSetup(
602                    Layout layout, String portletId) {
603    
604                    return getPortletSetup(
605                            LayoutConstants.DEFAULT_PLID, layout, portletId, StringPool.BLANK,
606                            true);
607            }
608    
609            @Override
610            public String toXML(PortalPreferences portalPreferences) {
611                    PortalPreferencesImpl portalPreferencesImpl = null;
612    
613                    if (portalPreferences instanceof PortalPreferencesWrapper) {
614                            PortalPreferencesWrapper portalPreferencesWrapper =
615                                    (PortalPreferencesWrapper)portalPreferences;
616    
617                            portalPreferencesImpl =
618                                    portalPreferencesWrapper.getPortalPreferencesImpl();
619                    }
620                    else {
621                            portalPreferencesImpl = (PortalPreferencesImpl)portalPreferences;
622                    }
623    
624                    return portalPreferencesImpl.toXML();
625            }
626    
627            @Override
628            public String toXML(PortletPreferences portletPreferences) {
629                    PortletPreferencesImpl portletPreferencesImpl = null;
630    
631                    if (portletPreferences instanceof PortletPreferencesWrapper) {
632                            PortletPreferencesWrapper portletPreferencesWrapper =
633                                    (PortletPreferencesWrapper)portletPreferences;
634    
635                            portletPreferencesImpl =
636                                    portletPreferencesWrapper.getPortletPreferencesImpl();
637                    }
638                    else {
639                            portletPreferencesImpl = (PortletPreferencesImpl)portletPreferences;
640                    }
641    
642                    return portletPreferencesImpl.toXML();
643            }
644    
645            protected PortletPreferences getPortletSetup(
646                    long siteGroupId, Layout layout, String portletId,
647                    String defaultPreferences, boolean strictMode) {
648    
649                    String originalPortletId = portletId;
650    
651                    Portlet portlet = PortletLocalServiceUtil.getPortletById(
652                            layout.getCompanyId(), portletId);
653    
654                    boolean uniquePerLayout = false;
655                    boolean uniquePerGroup = false;
656    
657                    if (portlet.isPreferencesCompanyWide()) {
658                            portletId = PortletConstants.getRootPortletId(portletId);
659                    }
660                    else {
661                            if (portlet.isPreferencesUniquePerLayout()) {
662                                    uniquePerLayout = true;
663    
664                                    if (portlet.isPreferencesOwnedByGroup()) {
665                                            uniquePerGroup = true;
666                                    }
667                            }
668                            else {
669                                    if (portlet.isPreferencesOwnedByGroup()) {
670                                            uniquePerGroup = true;
671                                            portletId = PortletConstants.getRootPortletId(portletId);
672                                    }
673                            }
674                    }
675    
676                    long ownerId = PortletKeys.PREFS_OWNER_ID_DEFAULT;
677                    int ownerType = PortletKeys.PREFS_OWNER_TYPE_LAYOUT;
678                    long plid = layout.getPlid();
679    
680                    Group group = GroupLocalServiceUtil.fetchGroup(siteGroupId);
681    
682                    if ((group != null) && group.isLayout()) {
683                            plid = group.getClassPK();
684                    }
685    
686                    if (PortletConstants.hasUserId(originalPortletId)) {
687                            ownerId = PortletConstants.getUserId(originalPortletId);
688                            ownerType = PortletKeys.PREFS_OWNER_TYPE_USER;
689                    }
690                    else if (!uniquePerLayout) {
691                            plid = PortletKeys.PREFS_PLID_SHARED;
692    
693                            if (uniquePerGroup) {
694                                    if (siteGroupId > LayoutConstants.DEFAULT_PLID) {
695                                            ownerId = siteGroupId;
696                                    }
697                                    else {
698                                            ownerId = layout.getGroupId();
699                                    }
700    
701                                    ownerType = PortletKeys.PREFS_OWNER_TYPE_GROUP;
702                            }
703                            else {
704                                    ownerId = layout.getCompanyId();
705                                    ownerType = PortletKeys.PREFS_OWNER_TYPE_COMPANY;
706                            }
707                    }
708    
709                    if (strictMode) {
710                            return PortletPreferencesLocalServiceUtil.getStrictPreferences(
711                                    layout.getCompanyId(), ownerId, ownerType, plid, portletId);
712                    }
713    
714                    return PortletPreferencesLocalServiceUtil.getPreferences(
715                            layout.getCompanyId(), ownerId, ownerType, plid, portletId,
716                            defaultPreferences);
717            }
718    
719            protected Preference readPreference(XMLEventReader xmlEventReader)
720                    throws XMLStreamException {
721    
722                    String name = null;
723                    List<String> values = new ArrayList<String>();
724                    boolean readOnly = false;
725    
726                    while (xmlEventReader.hasNext()) {
727                            XMLEvent xmlEvent = xmlEventReader.nextEvent();
728    
729                            if (xmlEvent.isStartElement()) {
730                                    StartElement startElement = xmlEvent.asStartElement();
731    
732                                    String elementName = startElement.getName().getLocalPart();
733    
734                                    if (elementName.equals("name")) {
735                                            name = StAXReaderUtil.read(xmlEventReader);
736                                    }
737                                    else if (elementName.equals("value")) {
738                                            String value = StAXReaderUtil.read(xmlEventReader);
739    
740                                            values.add(value);
741                                    }
742                                    else if (elementName.equals("read-only")) {
743                                            String value = StAXReaderUtil.read(xmlEventReader);
744    
745                                            readOnly = GetterUtil.getBoolean(value);
746                                    }
747                            }
748                            else if (xmlEvent.isEndElement()) {
749                                    EndElement endElement = xmlEvent.asEndElement();
750    
751                                    String elementName = endElement.getName().getLocalPart();
752    
753                                    if (elementName.equals("preference")) {
754                                            break;
755                                    }
756                            }
757                    }
758    
759                    return new Preference(
760                            name, values.toArray(new String[values.size()]), readOnly);
761            }
762    
763            protected Map<String, Preference> toPreferencesMap(String xml) {
764                    if (Validator.isNull(xml)) {
765                            return Collections.emptyMap();
766                    }
767    
768                    Map<String, Preference> preferencesMap = _preferencesMapPortalCache.get(
769                            xml);
770    
771                    if (preferencesMap != null) {
772                            return preferencesMap;
773                    }
774    
775                    XMLEventReader xmlEventReader = null;
776    
777                    try {
778                            XMLInputFactory xmlInputFactory =
779                                    StAXReaderUtil.getXMLInputFactory();
780    
781                            xmlEventReader = xmlInputFactory.createXMLEventReader(
782                                    new UnsyncStringReader(xml));
783    
784                            while (xmlEventReader.hasNext()) {
785                                    XMLEvent xmlEvent = xmlEventReader.nextEvent();
786    
787                                    if (xmlEvent.isStartElement()) {
788                                            StartElement startElement = xmlEvent.asStartElement();
789    
790                                            String elementName = startElement.getName().getLocalPart();
791    
792                                            if (elementName.equals("preference")) {
793                                                    Preference preference = readPreference(xmlEventReader);
794    
795                                                    if (preferencesMap == null) {
796                                                            preferencesMap = new HashMap<String, Preference>();
797                                                    }
798    
799                                                    preferencesMap.put(preference.getName(), preference);
800                                            }
801                                    }
802                            }
803                    }
804                    catch (XMLStreamException xse) {
805                            throw new SystemException(xse);
806                    }
807                    finally {
808                            if (xmlEventReader != null) {
809                                    try {
810                                            xmlEventReader.close();
811                                    }
812                                    catch (XMLStreamException xse) {
813                                    }
814                            }
815                    }
816    
817                    if (preferencesMap == null) {
818                            preferencesMap = Collections.emptyMap();
819                    }
820    
821                    _preferencesMapPortalCache.put(xml, preferencesMap);
822    
823                    return preferencesMap;
824            }
825    
826            private final PortalCache<String, Map<String, Preference>>
827                    _preferencesMapPortalCache = SingleVMPoolUtil.getCache(
828                            PortletPreferencesFactoryImpl.class.getName());
829    
830    }