001    /**
002     * Copyright (c) 2000-2013 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.portal.lar;
016    
017    import com.liferay.portal.NoSuchRoleException;
018    import com.liferay.portal.NoSuchTeamException;
019    import com.liferay.portal.kernel.bean.BeanPropertiesUtil;
020    import com.liferay.portal.kernel.exception.PortalException;
021    import com.liferay.portal.kernel.exception.SystemException;
022    import com.liferay.portal.kernel.lar.PortletDataContext;
023    import com.liferay.portal.kernel.lar.PortletDataContextListener;
024    import com.liferay.portal.kernel.lar.PortletDataException;
025    import com.liferay.portal.kernel.lar.PortletDataHandlerControl;
026    import com.liferay.portal.kernel.lar.PortletDataHandlerKeys;
027    import com.liferay.portal.kernel.lar.UserIdStrategy;
028    import com.liferay.portal.kernel.log.Log;
029    import com.liferay.portal.kernel.log.LogFactoryUtil;
030    import com.liferay.portal.kernel.util.KeyValuePair;
031    import com.liferay.portal.kernel.util.ListUtil;
032    import com.liferay.portal.kernel.util.MapUtil;
033    import com.liferay.portal.kernel.util.PrimitiveLongList;
034    import com.liferay.portal.kernel.util.StringPool;
035    import com.liferay.portal.kernel.util.StringUtil;
036    import com.liferay.portal.kernel.util.Validator;
037    import com.liferay.portal.kernel.workflow.WorkflowConstants;
038    import com.liferay.portal.kernel.xml.Attribute;
039    import com.liferay.portal.kernel.xml.Element;
040    import com.liferay.portal.kernel.zip.ZipReader;
041    import com.liferay.portal.kernel.zip.ZipWriter;
042    import com.liferay.portal.model.AttachedModel;
043    import com.liferay.portal.model.AuditedModel;
044    import com.liferay.portal.model.ClassedModel;
045    import com.liferay.portal.model.Group;
046    import com.liferay.portal.model.Layout;
047    import com.liferay.portal.model.Lock;
048    import com.liferay.portal.model.ResourceConstants;
049    import com.liferay.portal.model.ResourcedModel;
050    import com.liferay.portal.model.Role;
051    import com.liferay.portal.model.RoleConstants;
052    import com.liferay.portal.model.Team;
053    import com.liferay.portal.model.impl.LockImpl;
054    import com.liferay.portal.security.permission.ResourceActionsUtil;
055    import com.liferay.portal.service.GroupLocalServiceUtil;
056    import com.liferay.portal.service.LockLocalServiceUtil;
057    import com.liferay.portal.service.PermissionLocalServiceUtil;
058    import com.liferay.portal.service.ResourceBlockLocalServiceUtil;
059    import com.liferay.portal.service.ResourceBlockPermissionLocalServiceUtil;
060    import com.liferay.portal.service.ResourcePermissionLocalServiceUtil;
061    import com.liferay.portal.service.RoleLocalServiceUtil;
062    import com.liferay.portal.service.ServiceContext;
063    import com.liferay.portal.service.TeamLocalServiceUtil;
064    import com.liferay.portal.util.PortalUtil;
065    import com.liferay.portal.util.PropsValues;
066    import com.liferay.portlet.asset.NoSuchEntryException;
067    import com.liferay.portlet.asset.model.AssetCategory;
068    import com.liferay.portlet.asset.model.AssetEntry;
069    import com.liferay.portlet.asset.model.AssetLink;
070    import com.liferay.portlet.asset.service.AssetCategoryLocalServiceUtil;
071    import com.liferay.portlet.asset.service.AssetEntryLocalServiceUtil;
072    import com.liferay.portlet.asset.service.AssetLinkLocalServiceUtil;
073    import com.liferay.portlet.asset.service.AssetTagLocalServiceUtil;
074    import com.liferay.portlet.blogs.model.impl.BlogsEntryImpl;
075    import com.liferay.portlet.bookmarks.model.impl.BookmarksEntryImpl;
076    import com.liferay.portlet.bookmarks.model.impl.BookmarksFolderImpl;
077    import com.liferay.portlet.calendar.model.impl.CalEventImpl;
078    import com.liferay.portlet.documentlibrary.model.impl.DLFileEntryImpl;
079    import com.liferay.portlet.documentlibrary.model.impl.DLFileRankImpl;
080    import com.liferay.portlet.documentlibrary.model.impl.DLFileShortcutImpl;
081    import com.liferay.portlet.documentlibrary.model.impl.DLFolderImpl;
082    import com.liferay.portlet.expando.model.ExpandoBridge;
083    import com.liferay.portlet.expando.model.ExpandoColumn;
084    import com.liferay.portlet.expando.service.ExpandoColumnLocalServiceUtil;
085    import com.liferay.portlet.journal.model.impl.JournalArticleImpl;
086    import com.liferay.portlet.journal.model.impl.JournalFeedImpl;
087    import com.liferay.portlet.journal.model.impl.JournalStructureImpl;
088    import com.liferay.portlet.journal.model.impl.JournalTemplateImpl;
089    import com.liferay.portlet.messageboards.model.MBDiscussion;
090    import com.liferay.portlet.messageboards.model.MBMessage;
091    import com.liferay.portlet.messageboards.model.MBThread;
092    import com.liferay.portlet.messageboards.model.impl.MBBanImpl;
093    import com.liferay.portlet.messageboards.model.impl.MBCategoryImpl;
094    import com.liferay.portlet.messageboards.model.impl.MBMessageImpl;
095    import com.liferay.portlet.messageboards.model.impl.MBThreadFlagImpl;
096    import com.liferay.portlet.messageboards.service.MBMessageLocalServiceUtil;
097    import com.liferay.portlet.messageboards.service.MBThreadLocalServiceUtil;
098    import com.liferay.portlet.messageboards.service.persistence.MBDiscussionUtil;
099    import com.liferay.portlet.messageboards.service.persistence.MBMessageUtil;
100    import com.liferay.portlet.polls.model.impl.PollsChoiceImpl;
101    import com.liferay.portlet.polls.model.impl.PollsQuestionImpl;
102    import com.liferay.portlet.polls.model.impl.PollsVoteImpl;
103    import com.liferay.portlet.ratings.model.RatingsEntry;
104    import com.liferay.portlet.ratings.model.impl.RatingsEntryImpl;
105    import com.liferay.portlet.ratings.service.RatingsEntryLocalServiceUtil;
106    import com.liferay.portlet.wiki.model.impl.WikiNodeImpl;
107    import com.liferay.portlet.wiki.model.impl.WikiPageImpl;
108    
109    import com.thoughtworks.xstream.XStream;
110    
111    import java.io.IOException;
112    import java.io.InputStream;
113    import java.io.Serializable;
114    
115    import java.util.ArrayList;
116    import java.util.Collections;
117    import java.util.Date;
118    import java.util.HashMap;
119    import java.util.HashSet;
120    import java.util.Iterator;
121    import java.util.List;
122    import java.util.Map;
123    import java.util.Set;
124    
125    import jodd.bean.BeanUtil;
126    
127    /**
128     * <p>
129     * Holds context information that is used during exporting and importing portlet
130     * data.
131     * </p>
132     *
133     * @author Brian Wing Shun Chan
134     * @author Raymond Aug??
135     * @author Bruno Farache
136     * @author Alex Chow
137     */
138    public class PortletDataContextImpl implements PortletDataContext {
139    
140            public PortletDataContextImpl(
141                            long companyId, long groupId, Map<String, String[]> parameterMap,
142                            Set<String> primaryKeys, Date startDate, Date endDate,
143                            ZipWriter zipWriter)
144                    throws PortletDataException {
145    
146                    validateDateRange(startDate, endDate);
147    
148                    _companyId = companyId;
149    
150                    try {
151                            Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
152                                    _companyId);
153    
154                            _companyGroupId = companyGroup.getGroupId();
155                    }
156                    catch (Exception e) {
157                            throw new IllegalStateException(e);
158                    }
159    
160                    _groupId = groupId;
161                    _scopeGroupId = groupId;
162                    _parameterMap = parameterMap;
163                    _primaryKeys = primaryKeys;
164                    _dataStrategy = null;
165                    _userIdStrategy = null;
166                    _startDate = startDate;
167                    _endDate = endDate;
168                    _zipReader = null;
169                    _zipWriter = zipWriter;
170    
171                    initXStream();
172            }
173    
174            public PortletDataContextImpl(
175                    long companyId, long groupId, Map<String, String[]> parameterMap,
176                    Set<String> primaryKeys, UserIdStrategy userIdStrategy,
177                    ZipReader zipReader) {
178    
179                    _companyId = companyId;
180    
181                    try {
182                            Group companyGroup = GroupLocalServiceUtil.getCompanyGroup(
183                                    _companyId);
184    
185                            _companyGroupId = companyGroup.getGroupId();
186                    }
187                    catch (Exception e) {
188                            throw new IllegalStateException(e);
189                    }
190    
191                    _groupId = groupId;
192                    _scopeGroupId = groupId;
193                    _parameterMap = parameterMap;
194                    _primaryKeys = primaryKeys;
195                    _dataStrategy = MapUtil.getString(
196                            parameterMap, PortletDataHandlerKeys.DATA_STRATEGY,
197                            PortletDataHandlerKeys.DATA_STRATEGY_MIRROR);
198                    _userIdStrategy = userIdStrategy;
199                    _zipReader = zipReader;
200                    _zipWriter = null;
201    
202                    initXStream();
203            }
204    
205            @Override
206            public void addAssetCategories(Class<?> clazz, long classPK)
207                    throws SystemException {
208    
209                    List<AssetCategory> assetCategories =
210                            AssetCategoryLocalServiceUtil.getCategories(
211                                    clazz.getName(), classPK);
212    
213                    _assetCategoryUuidsMap.put(
214                            getPrimaryKeyString(clazz, classPK),
215                            StringUtil.split(
216                                    ListUtil.toString(
217                                            assetCategories, AssetCategory.UUID_ACCESSOR)));
218                    _assetCategoryIdsMap.put(
219                            getPrimaryKeyString(clazz, classPK),
220                            StringUtil.split(
221                                    ListUtil.toString(
222                                            assetCategories, AssetCategory.CATEGORY_ID_ACCESSOR), 0L));
223            }
224    
225            @Override
226            public void addAssetCategories(
227                    String className, long classPK, long[] assetCategoryIds) {
228    
229                    _assetCategoryIdsMap.put(
230                            getPrimaryKeyString(className, classPK), assetCategoryIds);
231            }
232    
233            public void addAssetLinks(Class<?> clazz, long classPK)
234                    throws PortalException, SystemException {
235    
236                    AssetEntry assetEntry = null;
237    
238                    try {
239                            assetEntry = AssetEntryLocalServiceUtil.getEntry(
240                                    clazz.getName(), classPK);
241                    }
242                    catch (NoSuchEntryException nsee) {
243                            return;
244                    }
245    
246                    List<AssetLink> directAssetLinks =
247                            AssetLinkLocalServiceUtil.getDirectLinks(assetEntry.getEntryId());
248    
249                    if (directAssetLinks.isEmpty()) {
250                            return;
251                    }
252    
253                    Map<Integer, List<AssetLink>> assetLinksMap =
254                            new HashMap<Integer, List<AssetLink>>();
255    
256                    for (AssetLink assetLink : directAssetLinks) {
257                            List<AssetLink> assetLinks = assetLinksMap.get(assetLink.getType());
258    
259                            if (assetLinks == null) {
260                                    assetLinks = new ArrayList<AssetLink>();
261    
262                                    assetLinksMap.put(assetLink.getType(), assetLinks);
263                            }
264    
265                            assetLinks.add(assetLink);
266                    }
267    
268                    for (Map.Entry<Integer, List<AssetLink>> entry :
269                                    assetLinksMap.entrySet()) {
270    
271                            int assetLinkType = entry.getKey();
272                            List<AssetLink> assetLinks = entry.getValue();
273    
274                            List<String> assetLinkUuids = new ArrayList<String>(
275                                    directAssetLinks.size());
276    
277                            for (AssetLink assetLink : assetLinks) {
278                                    try {
279                                            AssetEntry assetLinkEntry =
280                                                    AssetEntryLocalServiceUtil.getEntry(
281                                                            assetLink.getEntryId2());
282    
283                                            assetLinkUuids.add(assetLinkEntry.getClassUuid());
284                                    }
285                                    catch (NoSuchEntryException nsee) {
286                                    }
287                            }
288    
289                            _assetLinkUuidsMap.put(
290                                    getPrimaryKeyString(
291                                            assetEntry.getClassUuid(), String.valueOf(assetLinkType)),
292                                    assetLinkUuids.toArray(new String[assetLinkUuids.size()]));
293                    }
294            }
295    
296            @Override
297            public void addAssetTags(Class<?> clazz, long classPK)
298                    throws SystemException {
299    
300                    String[] tagNames = AssetTagLocalServiceUtil.getTagNames(
301                            clazz.getName(), classPK);
302    
303                    _assetTagNamesMap.put(getPrimaryKeyString(clazz, classPK), tagNames);
304            }
305    
306            @Override
307            public void addAssetTags(
308                    String className, long classPK, String[] assetTagNames) {
309    
310                    _assetTagNamesMap.put(
311                            getPrimaryKeyString(className, classPK), assetTagNames);
312            }
313    
314            @Override
315            public void addClassedModel(
316                            Element element, String path, ClassedModel classedModel,
317                            String namespace)
318                    throws PortalException, SystemException {
319    
320                    element.addAttribute("path", path);
321    
322                    if (classedModel instanceof AttachedModel) {
323                            AttachedModel attachedModel = (AttachedModel)classedModel;
324    
325                            element.addAttribute("class-name", attachedModel.getClassName());
326                    }
327                    else if (BeanUtil.hasProperty(classedModel, "className")) {
328                            String className = BeanPropertiesUtil.getStringSilent(
329                                    classedModel, "className");
330    
331                            if (className != null) {
332                                    element.addAttribute("class-name", className);
333                            }
334                    }
335    
336                    if (classedModel instanceof AuditedModel) {
337                            AuditedModel auditedModel = (AuditedModel)classedModel;
338    
339                            auditedModel.setUserUuid(auditedModel.getUserUuid());
340                    }
341    
342                    if (!isResourceMain(classedModel)) {
343                            addZipEntry(path, classedModel);
344    
345                            return;
346                    }
347    
348                    Class<?> clazz = classedModel.getModelClass();
349                    long classPK = getClassPK(classedModel);
350    
351                    addAssetLinks(clazz, classPK);
352                    addExpando(element, path, classedModel);
353                    addLocks(clazz, String.valueOf(classPK));
354                    addPermissions(clazz, classPK);
355    
356                    boolean portletMetadataAll = getBooleanParameter(
357                            namespace, PortletDataHandlerKeys.PORTLET_METADATA_ALL);
358    
359                    if (portletMetadataAll ||
360                            getBooleanParameter(namespace, "categories")) {
361    
362                            addAssetCategories(clazz, classPK);
363                    }
364    
365                    if (portletMetadataAll || getBooleanParameter(namespace, "comments")) {
366                            addComments(clazz, classPK);
367                    }
368    
369                    if (portletMetadataAll || getBooleanParameter(namespace, "ratings")) {
370                            addRatingsEntries(clazz, classPK);
371                    }
372    
373                    if (portletMetadataAll || getBooleanParameter(namespace, "tags")) {
374                            addAssetTags(clazz, classPK);
375                    }
376    
377                    addZipEntry(path, classedModel);
378            }
379    
380            @Override
381            public void addComments(Class<?> clazz, long classPK)
382                    throws SystemException {
383    
384                    long classNameId = PortalUtil.getClassNameId(clazz);
385    
386                    MBDiscussion discussion = MBDiscussionUtil.fetchByC_C(
387                            classNameId, classPK);
388    
389                    if (discussion == null) {
390                            return;
391                    }
392    
393                    List<MBMessage> messages = MBMessageLocalServiceUtil.getThreadMessages(
394                            discussion.getThreadId(), WorkflowConstants.STATUS_APPROVED);
395    
396                    if (messages.isEmpty()) {
397                            return;
398                    }
399    
400                    MBMessage firstMessage = messages.get(0);
401    
402                    if ((messages.size() == 1) && firstMessage.isRoot()) {
403                            return;
404                    }
405    
406                    Iterator<MBMessage> itr = messages.iterator();
407    
408                    while (itr.hasNext()) {
409                            MBMessage message = itr.next();
410    
411                            message.setUserUuid(message.getUserUuid());
412    
413                            addRatingsEntries(MBDiscussion.class, message.getPrimaryKey());
414                    }
415    
416                    _commentsMap.put(getPrimaryKeyString(clazz, classPK), messages);
417            }
418    
419            @Override
420            public void addComments(
421                    String className, long classPK, List<MBMessage> messages) {
422    
423                    _commentsMap.put(getPrimaryKeyString(className, classPK), messages);
424            }
425    
426            @Override
427            public void addExpando(
428                            Element element, String path, ClassedModel classedModel)
429                    throws PortalException, SystemException {
430    
431                    Class<?> clazz = classedModel.getModelClass();
432    
433                    String className = clazz.getName();
434    
435                    if (!_expandoColumnsMap.containsKey(className)) {
436                            List<ExpandoColumn> expandoColumns =
437                                    ExpandoColumnLocalServiceUtil.getDefaultTableColumns(
438                                            _companyId, className);
439    
440                            for (ExpandoColumn expandoColumn : expandoColumns) {
441                                    addPermissions(
442                                            ExpandoColumn.class, expandoColumn.getColumnId());
443                            }
444    
445                            _expandoColumnsMap.put(className, expandoColumns);
446                    }
447    
448                    ExpandoBridge expandoBridge = classedModel.getExpandoBridge();
449    
450                    Map<String, Serializable> expandoBridgeAttributes =
451                            expandoBridge.getAttributes();
452    
453                    if (!expandoBridgeAttributes.isEmpty()) {
454                            String expandoPath = getExpandoPath(path);
455    
456                            element.addAttribute("expando-path", expandoPath);
457    
458                            addZipEntry(expandoPath, expandoBridgeAttributes);
459                    }
460            }
461    
462            @Override
463            public void addLocks(Class<?> clazz, String key)
464                    throws PortalException, SystemException {
465    
466                    if (!_locksMap.containsKey(getPrimaryKeyString(clazz, key)) &&
467                            LockLocalServiceUtil.isLocked(clazz.getName(), key)) {
468    
469                            Lock lock = LockLocalServiceUtil.getLock(clazz.getName(), key);
470    
471                            addLocks(clazz.getName(), key, lock);
472                    }
473            }
474    
475            @Override
476            public void addLocks(String className, String key, Lock lock) {
477                    _locksMap.put(getPrimaryKeyString(className, key), lock);
478            }
479    
480            @Override
481            public void addPermissions(Class<?> clazz, long classPK)
482                    throws PortalException, SystemException {
483    
484                    addPermissions(clazz.getName(), classPK);
485            }
486    
487            @Override
488            public void addPermissions(String resourceName, long resourcePK)
489                    throws PortalException, SystemException {
490    
491                    if (((PropsValues.PERMISSIONS_USER_CHECK_ALGORITHM != 5) &&
492                             (PropsValues.PERMISSIONS_USER_CHECK_ALGORITHM != 6)) ||
493                            !MapUtil.getBoolean(
494                                    _parameterMap, PortletDataHandlerKeys.PERMISSIONS)) {
495    
496                            return;
497                    }
498    
499                    List<KeyValuePair> permissions = new ArrayList<KeyValuePair>();
500    
501                    Group group = GroupLocalServiceUtil.getGroup(_groupId);
502    
503                    List<Role> roles = RoleLocalServiceUtil.getRoles(_companyId);
504    
505                    PrimitiveLongList roleIds = new PrimitiveLongList(roles.size());
506                    Map<Long, String> roleIdsToNames = new HashMap<Long, String>();
507    
508                    for (Role role : roles) {
509                            int type = role.getType();
510    
511                            if ((type == RoleConstants.TYPE_REGULAR) ||
512                                    ((type == RoleConstants.TYPE_ORGANIZATION) &&
513                                     group.isOrganization()) ||
514                                    ((type == RoleConstants.TYPE_SITE) &&
515                                     (group.isLayout() || group.isLayoutSetPrototype() ||
516                                      group.isSite()))) {
517    
518                                    String name = role.getName();
519    
520                                    roleIds.add(role.getRoleId());
521                                    roleIdsToNames.put(role.getRoleId(), name);
522                            }
523                            else if ((type == RoleConstants.TYPE_PROVIDER) && role.isTeam()) {
524                                    Team team = TeamLocalServiceUtil.getTeam(role.getClassPK());
525    
526                                    if (team.getGroupId() == _groupId) {
527                                            String name =
528                                                    PermissionExporter.ROLE_TEAM_PREFIX + team.getName();
529    
530                                            roleIds.add(role.getRoleId());
531                                            roleIdsToNames.put(role.getRoleId(), name);
532                                    }
533                            }
534                    }
535    
536                    List<String> actionIds = ResourceActionsUtil.getModelResourceActions(
537                            resourceName);
538    
539                    if (PropsValues.PERMISSIONS_USER_CHECK_ALGORITHM == 5) {
540                            for (Map.Entry<Long, String> entry : roleIdsToNames.entrySet()) {
541                                    long roleId = entry.getKey();
542                                    String name = entry.getValue();
543    
544                                    String availableActionIds = getActionIds_5(
545                                            _companyId, roleId, resourceName,
546                                            String.valueOf(resourcePK), actionIds);
547    
548                                    KeyValuePair permission = new KeyValuePair(
549                                            name, availableActionIds);
550    
551                                    permissions.add(permission);
552                            }
553    
554                    }
555                    else if (PropsValues.PERMISSIONS_USER_CHECK_ALGORITHM == 6) {
556                            Map<Long, Set<String>> roleIdsToActionIds = getActionIds_6(
557                                    _companyId, roleIds.getArray(), resourceName, resourcePK,
558                                    actionIds);
559    
560                            for (Map.Entry<Long, String> entry : roleIdsToNames.entrySet()) {
561                                    long roleId = entry.getKey();
562                                    String name = entry.getValue();
563    
564                                    Set<String> availableActionIds = roleIdsToActionIds.get(roleId);
565    
566                                    if (availableActionIds == null) {
567                                            availableActionIds = Collections.emptySet();
568                                    }
569    
570                                    KeyValuePair permission = new KeyValuePair(
571                                            name, StringUtil.merge(availableActionIds));
572    
573                                    permissions.add(permission);
574                            }
575                    }
576    
577                    _permissionsMap.put(
578                            getPrimaryKeyString(resourceName, resourcePK), permissions);
579            }
580    
581            @Override
582            public void addPermissions(
583                    String resourceName, long resourcePK, List<KeyValuePair> permissions) {
584    
585                    if ((PropsValues.PERMISSIONS_USER_CHECK_ALGORITHM != 5) &&
586                            (PropsValues.PERMISSIONS_USER_CHECK_ALGORITHM != 6)) {
587    
588                            return;
589                    }
590    
591                    _permissionsMap.put(
592                            getPrimaryKeyString(resourceName, resourcePK), permissions);
593            }
594    
595            @Override
596            public boolean addPrimaryKey(Class<?> clazz, String primaryKey) {
597                    boolean value = hasPrimaryKey(clazz, primaryKey);
598    
599                    if (!value) {
600                            _primaryKeys.add(getPrimaryKeyString(clazz, primaryKey));
601                    }
602    
603                    return value;
604            }
605    
606            @Override
607            public void addRatingsEntries(Class<?> clazz, long classPK)
608                    throws SystemException {
609    
610                    List<RatingsEntry> ratingsEntries =
611                            RatingsEntryLocalServiceUtil.getEntries(clazz.getName(), classPK);
612    
613                    if (ratingsEntries.size() == 0) {
614                            return;
615                    }
616    
617                    Iterator<RatingsEntry> itr = ratingsEntries.iterator();
618    
619                    while (itr.hasNext()) {
620                            RatingsEntry entry = itr.next();
621    
622                            entry.setUserUuid(entry.getUserUuid());
623                    }
624    
625                    _ratingsEntriesMap.put(
626                            getPrimaryKeyString(clazz, classPK), ratingsEntries);
627            }
628    
629            @Override
630            public void addRatingsEntries(
631                    String className, long classPK, List<RatingsEntry> ratingsEntries) {
632    
633                    _ratingsEntriesMap.put(
634                            getPrimaryKeyString(className, classPK), ratingsEntries);
635            }
636    
637            @Override
638            public void addZipEntry(String path, byte[] bytes) throws SystemException {
639                    if (_portletDataContextListener != null) {
640                            _portletDataContextListener.onAddZipEntry(path);
641                    }
642    
643                    try {
644                            ZipWriter zipWriter = getZipWriter();
645    
646                            zipWriter.addEntry(path, bytes);
647                    }
648                    catch (IOException ioe) {
649                            throw new SystemException(ioe);
650                    }
651            }
652    
653            @Override
654            public void addZipEntry(String path, InputStream is)
655                    throws SystemException {
656    
657                    if (_portletDataContextListener != null) {
658                            _portletDataContextListener.onAddZipEntry(path);
659                    }
660    
661                    try {
662                            ZipWriter zipWriter = getZipWriter();
663    
664                            zipWriter.addEntry(path, is);
665                    }
666                    catch (IOException ioe) {
667                            throw new SystemException(ioe);
668                    }
669            }
670    
671            @Override
672            public void addZipEntry(String path, Object object) throws SystemException {
673                    addZipEntry(path, toXML(object));
674            }
675    
676            @Override
677            public void addZipEntry(String path, String s) throws SystemException {
678                    if (_portletDataContextListener != null) {
679                            _portletDataContextListener.onAddZipEntry(path);
680                    }
681    
682                    try {
683                            ZipWriter zipWriter = getZipWriter();
684    
685                            zipWriter.addEntry(path, s);
686                    }
687                    catch (IOException ioe) {
688                            throw new SystemException(ioe);
689                    }
690            }
691    
692            @Override
693            public void addZipEntry(String path, StringBuilder sb)
694                    throws SystemException {
695    
696                    if (_portletDataContextListener != null) {
697                            _portletDataContextListener.onAddZipEntry(path);
698                    }
699    
700                    try {
701                            ZipWriter zipWriter = getZipWriter();
702    
703                            zipWriter.addEntry(path, sb);
704                    }
705                    catch (IOException ioe) {
706                            throw new SystemException(ioe);
707                    }
708            }
709    
710            @Override
711            public ServiceContext createServiceContext(
712                    Element element, ClassedModel classedModel, String namespace) {
713    
714                    return createServiceContext(element, null, classedModel, namespace);
715            }
716    
717            @Override
718            public ServiceContext createServiceContext(
719                    String path, ClassedModel classedModel, String namespace) {
720    
721                    return createServiceContext(null, path, classedModel, namespace);
722            }
723    
724            @Override
725            public Object fromXML(byte[] bytes) {
726                    if ((bytes == null) || (bytes.length == 0)) {
727                            return null;
728                    }
729    
730                    return _xStream.fromXML(new String(bytes));
731            }
732    
733            @Override
734            public Object fromXML(String xml) {
735                    if (Validator.isNull(xml)) {
736                            return null;
737                    }
738    
739                    return _xStream.fromXML(xml);
740            }
741    
742            @Override
743            public long[] getAssetCategoryIds(Class<?> clazz, long classPK) {
744                    return _assetCategoryIdsMap.get(getPrimaryKeyString(clazz, classPK));
745            }
746    
747            @Override
748            public Map<String, long[]> getAssetCategoryIdsMap() {
749                    return _assetCategoryIdsMap;
750            }
751    
752            @Override
753            public Map<String, String[]> getAssetCategoryUuidsMap() {
754                    return _assetCategoryUuidsMap;
755            }
756    
757            @Override
758            public Map<String, String[]> getAssetLinkUuidsMap() {
759                    return _assetLinkUuidsMap;
760            }
761    
762            @Override
763            public String[] getAssetTagNames(Class<?> clazz, long classPK) {
764                    return _assetTagNamesMap.get(getPrimaryKeyString(clazz, classPK));
765            }
766    
767            @Override
768            public String[] getAssetTagNames(String className, long classPK) {
769                    return _assetTagNamesMap.get(getPrimaryKeyString(className, classPK));
770            }
771    
772            @Override
773            public Map<String, String[]> getAssetTagNamesMap() {
774                    return _assetTagNamesMap;
775            }
776    
777            @Override
778            public boolean getBooleanParameter(String namespace, String name) {
779                    boolean defaultValue = MapUtil.getBoolean(
780                            getParameterMap(),
781                            PortletDataHandlerKeys.PORTLET_DATA_CONTROL_DEFAULT, true);
782    
783                    return MapUtil.getBoolean(
784                            getParameterMap(),
785                            PortletDataHandlerControl.getNamespacedControlName(namespace, name),
786                            defaultValue);
787            }
788    
789            @Override
790            public ClassLoader getClassLoader() {
791                    return _xStream.getClassLoader();
792            }
793    
794            @Override
795            public Map<String, List<MBMessage>> getComments() {
796                    return _commentsMap;
797            }
798    
799            @Override
800            public long getCompanyGroupId() {
801                    return _companyGroupId;
802            }
803    
804            @Override
805            public long getCompanyId() {
806                    return _companyId;
807            }
808    
809            @Override
810            public String getDataStrategy() {
811                    return _dataStrategy;
812            }
813    
814            @Override
815            public Date getEndDate() {
816                    return _endDate;
817            }
818    
819            @Override
820            public Map<String, List<ExpandoColumn>> getExpandoColumns() {
821                    return _expandoColumnsMap;
822            }
823    
824            @Override
825            public long getGroupId() {
826                    return _groupId;
827            }
828    
829            @Override
830            public String getLayoutPath(long layoutId) {
831                    return getRootPath() + ROOT_PATH_LAYOUTS + layoutId;
832            }
833    
834            @Override
835            public Map<String, Lock> getLocks() {
836                    return _locksMap;
837            }
838    
839            @Override
840            public Map<?, ?> getNewPrimaryKeysMap(Class<?> clazz) {
841                    return getNewPrimaryKeysMap(clazz.getName());
842            }
843    
844            @Override
845            public Map<?, ?> getNewPrimaryKeysMap(String className) {
846                    Map<?, ?> map = _newPrimaryKeysMaps.get(className);
847    
848                    if (map == null) {
849                            map = new HashMap<Object, Object>();
850    
851                            _newPrimaryKeysMaps.put(className, map);
852                    }
853    
854                    return map;
855            }
856    
857            @Override
858            public long getOldPlid() {
859                    return _oldPlid;
860            }
861    
862            @Override
863            public Map<String, String[]> getParameterMap() {
864                    return _parameterMap;
865            }
866    
867            @Override
868            public Map<String, List<KeyValuePair>> getPermissions() {
869                    return _permissionsMap;
870            }
871    
872            @Override
873            public long getPlid() {
874                    return _plid;
875            }
876    
877            @Override
878            public String getPortletPath(String portletId) {
879                    return getRootPath() + ROOT_PATH_PORTLETS + portletId;
880            }
881    
882            @Override
883            public Set<String> getPrimaryKeys() {
884                    return _primaryKeys;
885            }
886    
887            @Override
888            public Map<String, List<RatingsEntry>> getRatingsEntries() {
889                    return _ratingsEntriesMap;
890            }
891    
892            @Override
893            public String getRootPath() {
894                    return ROOT_PATH_GROUPS + getScopeGroupId();
895            }
896    
897            @Override
898            public long getScopeGroupId() {
899                    return _scopeGroupId;
900            }
901    
902            @Override
903            public String getScopeLayoutUuid() {
904                    return _scopeLayoutUuid;
905            }
906    
907            @Override
908            public String getScopeType() {
909                    return _scopeType;
910            }
911    
912            @Override
913            public long getSourceCompanyGroupId() {
914                    return _sourceCompanyGroupId;
915            }
916    
917            @Override
918            public long getSourceGroupId() {
919                    return _sourceGroupId;
920            }
921    
922            @Override
923            public String getSourceLayoutPath(long layoutId) {
924                    return getSourceRootPath() + ROOT_PATH_LAYOUTS + layoutId;
925            }
926    
927            @Override
928            public String getSourcePortletPath(String portletId) {
929                    return getSourceRootPath() + ROOT_PATH_PORTLETS + portletId;
930            }
931    
932            @Override
933            public String getSourceRootPath() {
934                    return ROOT_PATH_GROUPS + getSourceGroupId();
935            }
936    
937            @Override
938            public Date getStartDate() {
939                    return _startDate;
940            }
941    
942            @Override
943            public long getUserId(String userUuid) throws SystemException {
944                    return _userIdStrategy.getUserId(userUuid);
945            }
946    
947            @Override
948            public UserIdStrategy getUserIdStrategy() {
949                    return _userIdStrategy;
950            }
951    
952            @Override
953            public List<String> getZipEntries() {
954                    return getZipReader().getEntries();
955            }
956    
957            @Override
958            public byte[] getZipEntryAsByteArray(String path) {
959                    if (!Validator.isFilePath(path, false)) {
960                            return null;
961                    }
962    
963                    if (_portletDataContextListener != null) {
964                            _portletDataContextListener.onGetZipEntry(path);
965                    }
966    
967                    return getZipReader().getEntryAsByteArray(path);
968            }
969    
970            @Override
971            public InputStream getZipEntryAsInputStream(String path) {
972                    if (!Validator.isFilePath(path, false)) {
973                            return null;
974                    }
975    
976                    if (_portletDataContextListener != null) {
977                            _portletDataContextListener.onGetZipEntry(path);
978                    }
979    
980                    return getZipReader().getEntryAsInputStream(path);
981            }
982    
983            @Override
984            public Object getZipEntryAsObject(Element element, String path) {
985                    Object object = fromXML(getZipEntryAsString(path));
986    
987                    Attribute classNameAttribute = element.attribute("class-name");
988    
989                    if (classNameAttribute != null) {
990                            BeanPropertiesUtil.setProperty(
991                                    object, "className", classNameAttribute.getText());
992                    }
993    
994                    return object;
995            }
996    
997            @Override
998            public Object getZipEntryAsObject(String path) {
999                    return fromXML(getZipEntryAsString(path));
1000            }
1001    
1002            @Override
1003            public String getZipEntryAsString(String path) {
1004                    if (!Validator.isFilePath(path, false)) {
1005                            return null;
1006                    }
1007    
1008                    if (_portletDataContextListener != null) {
1009                            _portletDataContextListener.onGetZipEntry(path);
1010                    }
1011    
1012                    return getZipReader().getEntryAsString(path);
1013            }
1014    
1015            @Override
1016            public List<String> getZipFolderEntries() {
1017                    return getZipFolderEntries(StringPool.SLASH);
1018            }
1019    
1020            @Override
1021            public List<String> getZipFolderEntries(String path) {
1022                    if (!Validator.isFilePath(path, false)) {
1023                            return null;
1024                    }
1025    
1026                    return getZipReader().getFolderEntries(path);
1027            }
1028    
1029            @Override
1030            public ZipReader getZipReader() {
1031                    return _zipReader;
1032            }
1033    
1034            @Override
1035            public ZipWriter getZipWriter() {
1036                    return _zipWriter;
1037            }
1038    
1039            @Override
1040            public boolean hasDateRange() {
1041                    if (_startDate != null) {
1042                            return true;
1043                    }
1044                    else {
1045                            return false;
1046                    }
1047            }
1048    
1049            @Override
1050            public boolean hasNotUniquePerLayout(String dataKey) {
1051                    return _notUniquePerLayout.contains(dataKey);
1052            }
1053    
1054            @Override
1055            public boolean hasPrimaryKey(Class<?> clazz, String primaryKey) {
1056                    return _primaryKeys.contains(getPrimaryKeyString(clazz, primaryKey));
1057            }
1058    
1059            @Override
1060            public void importClassedModel(
1061                            ClassedModel classedModel, ClassedModel newClassedModel,
1062                            String namespace)
1063                    throws PortalException, SystemException {
1064    
1065                    if (!isResourceMain(classedModel)) {
1066                            return;
1067                    }
1068    
1069                    Class<?> clazz = classedModel.getModelClass();
1070                    long classPK = getClassPK(classedModel);
1071    
1072                    long newClassPK = getClassPK(newClassedModel);
1073    
1074                    Map<Long, Long> newPrimaryKeysMap =
1075                            (Map<Long, Long>)getNewPrimaryKeysMap(clazz);
1076    
1077                    newPrimaryKeysMap.put(classPK, newClassPK);
1078    
1079                    importLocks(clazz, String.valueOf(classPK), String.valueOf(newClassPK));
1080                    importPermissions(clazz, classPK, newClassPK);
1081    
1082                    boolean portletMetadataAll = getBooleanParameter(
1083                            namespace, PortletDataHandlerKeys.PORTLET_METADATA_ALL);
1084    
1085                    if (portletMetadataAll || getBooleanParameter(namespace, "comments")) {
1086                            importComments(clazz, classPK, newClassPK, getScopeGroupId());
1087                    }
1088    
1089                    if (portletMetadataAll || getBooleanParameter(namespace, "ratings")) {
1090                            importRatingsEntries(clazz, classPK, newClassPK);
1091                    }
1092            }
1093    
1094            @Override
1095            public void importComments(
1096                            Class<?> clazz, long classPK, long newClassPK, long groupId)
1097                    throws PortalException, SystemException {
1098    
1099                    Map<Long, Long> messagePKs = new HashMap<Long, Long>();
1100                    Map<Long, Long> threadPKs = new HashMap<Long, Long>();
1101    
1102                    List<MBMessage> messages = _commentsMap.get(
1103                            getPrimaryKeyString(clazz, classPK));
1104    
1105                    if (messages == null) {
1106                            return;
1107                    }
1108    
1109                    MBMessage firstMessage = messages.get(0);
1110    
1111                    if ((messages.size() == 1) && firstMessage.isRoot()) {
1112                            return;
1113                    }
1114    
1115                    long classNameId = PortalUtil.getClassNameId(clazz);
1116    
1117                    MBDiscussion discussion = MBDiscussionUtil.fetchByC_C(
1118                            classNameId, newClassPK);
1119    
1120                    for (MBMessage message : messages) {
1121                            long userId = getUserId(message.getUserUuid());
1122                            long parentMessageId = MapUtil.getLong(
1123                                    messagePKs, message.getParentMessageId(),
1124                                    message.getParentMessageId());
1125                            long threadId = MapUtil.getLong(
1126                                    threadPKs, message.getThreadId(), message.getThreadId());
1127    
1128                            if (message.isRoot()) {
1129                                    if (discussion != null) {
1130                                            MBThread thread = MBThreadLocalServiceUtil.getThread(
1131                                                    discussion.getThreadId());
1132    
1133                                            long rootMessageId = thread.getRootMessageId();
1134    
1135                                            messagePKs.put(message.getMessageId(), rootMessageId);
1136                                            threadPKs.put(message.getThreadId(), thread.getThreadId());
1137                                    }
1138                                    else if (clazz == Layout.class) {
1139                                            MBMessage importedMessage =
1140                                                    MBMessageLocalServiceUtil.addDiscussionMessage(
1141                                                            userId, message.getUserName(), groupId,
1142                                                            clazz.getName(), newClassPK,
1143                                                            WorkflowConstants.ACTION_PUBLISH);
1144    
1145                                            messagePKs.put(
1146                                                    message.getMessageId(), importedMessage.getMessageId());
1147                                            threadPKs.put(
1148                                                    message.getThreadId(), importedMessage.getThreadId());
1149                                    }
1150                            }
1151                            else {
1152                                    ServiceContext serviceContext = new ServiceContext();
1153    
1154                                    serviceContext.setCreateDate(message.getCreateDate());
1155                                    serviceContext.setModifiedDate(message.getModifiedDate());
1156                                    serviceContext.setScopeGroupId(groupId);
1157    
1158                                    MBMessage importedMessage = null;
1159    
1160                                    if (_dataStrategy.equals(
1161                                                    PortletDataHandlerKeys.DATA_STRATEGY_MIRROR) ||
1162                                            _dataStrategy.equals(
1163                                                    PortletDataHandlerKeys.
1164                                                            DATA_STRATEGY_MIRROR_OVERWRITE)) {
1165    
1166                                            MBMessage existingMessage = MBMessageUtil.fetchByUUID_G(
1167                                                    message.getUuid(), groupId);
1168    
1169                                            if (existingMessage == null) {
1170                                                    serviceContext.setUuid(message.getUuid());
1171    
1172                                                    importedMessage =
1173                                                            MBMessageLocalServiceUtil.addDiscussionMessage(
1174                                                                    userId, message.getUserName(), groupId,
1175                                                                    clazz.getName(), newClassPK, threadId,
1176                                                                    parentMessageId, message.getSubject(),
1177                                                                    message.getBody(), serviceContext);
1178                                            }
1179                                            else {
1180                                                    serviceContext.setWorkflowAction(
1181                                                            WorkflowConstants.ACTION_PUBLISH);
1182    
1183                                                    importedMessage =
1184                                                            MBMessageLocalServiceUtil.updateDiscussionMessage(
1185                                                                    userId, existingMessage.getMessageId(),
1186                                                                    clazz.getName(), newClassPK,
1187                                                                    message.getSubject(), message.getBody(),
1188                                                                    serviceContext);
1189                                            }
1190                                    }
1191                                    else {
1192                                            importedMessage =
1193                                                    MBMessageLocalServiceUtil.addDiscussionMessage(
1194                                                            userId, message.getUserName(), groupId,
1195                                                            clazz.getName(), newClassPK, threadId,
1196                                                            parentMessageId, message.getSubject(),
1197                                                            message.getBody(), serviceContext);
1198                                    }
1199    
1200                                    messagePKs.put(
1201                                            message.getMessageId(), importedMessage.getMessageId());
1202                                    threadPKs.put(
1203                                            message.getThreadId(), importedMessage.getThreadId());
1204                            }
1205    
1206                            importRatingsEntries(
1207                                    MBDiscussion.class, message.getPrimaryKey(),
1208                                    messagePKs.get(message.getPrimaryKey()));
1209                    }
1210            }
1211    
1212            @Override
1213            public void importLocks(Class<?> clazz, String key, String newKey)
1214                    throws PortalException, SystemException {
1215    
1216                    Lock lock = _locksMap.get(getPrimaryKeyString(clazz, key));
1217    
1218                    if (lock == null) {
1219                            return;
1220                    }
1221    
1222                    long userId = getUserId(lock.getUserUuid());
1223    
1224                    long expirationTime = 0;
1225    
1226                    if (lock.getExpirationDate() != null) {
1227                            Date expirationDate = lock.getExpirationDate();
1228    
1229                            expirationTime = expirationDate.getTime();
1230                    }
1231    
1232                    LockLocalServiceUtil.lock(
1233                            userId, clazz.getName(), newKey, lock.getOwner(),
1234                            lock.isInheritable(), expirationTime);
1235            }
1236    
1237            @Override
1238            public void importPermissions(Class<?> clazz, long classPK, long newClassPK)
1239                    throws PortalException, SystemException {
1240    
1241                    importPermissions(clazz.getName(), classPK, newClassPK);
1242            }
1243    
1244            @Override
1245            public void importPermissions(
1246                            String resourceName, long resourcePK, long newResourcePK)
1247                    throws PortalException, SystemException {
1248    
1249                    if (((PropsValues.PERMISSIONS_USER_CHECK_ALGORITHM != 5) &&
1250                             (PropsValues.PERMISSIONS_USER_CHECK_ALGORITHM != 6)) ||
1251                            !MapUtil.getBoolean(
1252                                    _parameterMap, PortletDataHandlerKeys.PERMISSIONS)) {
1253    
1254                            return;
1255                    }
1256    
1257                    List<KeyValuePair> permissions = _permissionsMap.get(
1258                            getPrimaryKeyString(resourceName, resourcePK));
1259    
1260                    if (permissions == null) {
1261                            return;
1262                    }
1263    
1264                    Map<Long, String[]> roleIdsToActionIds = new HashMap<Long, String[]>();
1265    
1266                    for (KeyValuePair permission : permissions) {
1267                            String roleName = permission.getKey();
1268    
1269                            Role role = null;
1270    
1271                            Team team = null;
1272    
1273                            if (roleName.startsWith(PermissionExporter.ROLE_TEAM_PREFIX)) {
1274                                    roleName = roleName.substring(
1275                                            PermissionExporter.ROLE_TEAM_PREFIX.length());
1276    
1277                                    try {
1278                                            team = TeamLocalServiceUtil.getTeam(_groupId, roleName);
1279                                    }
1280                                    catch (NoSuchTeamException nste) {
1281                                            if (_log.isWarnEnabled()) {
1282                                                    _log.warn("Team " + roleName + " does not exist");
1283                                            }
1284    
1285                                            continue;
1286                                    }
1287                            }
1288    
1289                            try {
1290                                    if (team != null) {
1291                                            role = RoleLocalServiceUtil.getTeamRole(
1292                                                    _companyId, team.getTeamId());
1293                                    }
1294                                    else {
1295                                            role = RoleLocalServiceUtil.getRole(_companyId, roleName);
1296                                    }
1297                            }
1298                            catch (NoSuchRoleException nsre) {
1299                                    if (_log.isWarnEnabled()) {
1300                                            _log.warn("Role " + roleName + " does not exist");
1301                                    }
1302    
1303                                    continue;
1304                            }
1305    
1306                            String[] actionIds = StringUtil.split(permission.getValue());
1307    
1308                            roleIdsToActionIds.put(role.getRoleId(), actionIds);
1309                    }
1310    
1311                    if (roleIdsToActionIds.isEmpty()) {
1312                            return;
1313                    }
1314    
1315                    if (PropsValues.PERMISSIONS_USER_CHECK_ALGORITHM == 5) {
1316                            PermissionLocalServiceUtil.setRolesPermissions(
1317                                    _companyId, roleIdsToActionIds, resourceName,
1318                                    ResourceConstants.SCOPE_INDIVIDUAL,
1319                                    String.valueOf(newResourcePK));
1320                    }
1321                    else if (PropsValues.PERMISSIONS_USER_CHECK_ALGORITHM == 6) {
1322                            if (ResourceBlockLocalServiceUtil.isSupported(resourceName)) {
1323                                    ResourceBlockLocalServiceUtil.setIndividualScopePermissions(
1324                                            _companyId, _groupId, resourceName, newResourcePK,
1325                                            roleIdsToActionIds);
1326                            }
1327                            else {
1328                                    ResourcePermissionLocalServiceUtil.setResourcePermissions(
1329                                            _companyId, resourceName,
1330                                            ResourceConstants.SCOPE_INDIVIDUAL,
1331                                            String.valueOf(newResourcePK), roleIdsToActionIds);
1332                            }
1333                    }
1334            }
1335    
1336            @Override
1337            public void importRatingsEntries(
1338                            Class<?> clazz, long classPK, long newClassPK)
1339                    throws PortalException, SystemException {
1340    
1341                    List<RatingsEntry> ratingsEntries = _ratingsEntriesMap.get(
1342                            getPrimaryKeyString(clazz, classPK));
1343    
1344                    if (ratingsEntries == null) {
1345                            return;
1346                    }
1347    
1348                    ServiceContext serviceContext = new ServiceContext();
1349    
1350                    for (RatingsEntry ratingsEntry : ratingsEntries) {
1351                            long userId = getUserId(ratingsEntry.getUserUuid());
1352    
1353                            serviceContext.setCreateDate(ratingsEntry.getCreateDate());
1354                            serviceContext.setModifiedDate(ratingsEntry.getModifiedDate());
1355    
1356                            RatingsEntryLocalServiceUtil.updateEntry(
1357                                    userId, clazz.getName(), newClassPK, ratingsEntry.getScore(),
1358                                    serviceContext);
1359                    }
1360            }
1361    
1362            @Override
1363            public boolean isDataStrategyMirror() {
1364                    if (_dataStrategy.equals(PortletDataHandlerKeys.DATA_STRATEGY_MIRROR) ||
1365                            _dataStrategy.equals(
1366                                    PortletDataHandlerKeys.DATA_STRATEGY_MIRROR_OVERWRITE)) {
1367    
1368                            return true;
1369                    }
1370                    else {
1371                            return false;
1372                    }
1373            }
1374    
1375            @Override
1376            public boolean isDataStrategyMirrorWithOverwriting() {
1377                    if (_dataStrategy.equals(
1378                                    PortletDataHandlerKeys.DATA_STRATEGY_MIRROR_OVERWRITE)) {
1379    
1380                            return true;
1381                    }
1382                    else {
1383                            return false;
1384                    }
1385            }
1386    
1387            @Override
1388            public boolean isPathNotProcessed(String path) {
1389                    return !addPrimaryKey(String.class, path);
1390            }
1391    
1392            @Override
1393            public boolean isPerformDirectBinaryImport() {
1394                    return MapUtil.getBoolean(
1395                            _parameterMap, PortletDataHandlerKeys.PERFORM_DIRECT_BINARY_IMPORT);
1396            }
1397    
1398            @Override
1399            public boolean isPrivateLayout() {
1400                    return _privateLayout;
1401            }
1402    
1403            @Override
1404            public boolean isWithinDateRange(Date modifiedDate) {
1405                    if (!hasDateRange()) {
1406                            return true;
1407                    }
1408                    else if ((_startDate.compareTo(modifiedDate) <= 0) &&
1409                                     _endDate.after(modifiedDate)) {
1410    
1411                            return true;
1412                    }
1413                    else {
1414                            return false;
1415                    }
1416            }
1417    
1418            @Override
1419            public void putNotUniquePerLayout(String dataKey) {
1420                    _notUniquePerLayout.add(dataKey);
1421            }
1422    
1423            @Override
1424            public void setClassLoader(ClassLoader classLoader) {
1425                    _xStream.setClassLoader(classLoader);
1426            }
1427    
1428            @Override
1429            public void setGroupId(long groupId) {
1430                    _groupId = groupId;
1431            }
1432    
1433            @Override
1434            public void setOldPlid(long oldPlid) {
1435                    _oldPlid = oldPlid;
1436            }
1437    
1438            @Override
1439            public void setPlid(long plid) {
1440                    _plid = plid;
1441            }
1442    
1443            @Override
1444            public void setPortetDataContextListener(
1445                    PortletDataContextListener portletDataContextListener) {
1446    
1447                    _portletDataContextListener = portletDataContextListener;
1448            }
1449    
1450            @Override
1451            public void setPrivateLayout(boolean privateLayout) {
1452                    _privateLayout = privateLayout;
1453            }
1454    
1455            @Override
1456            public void setScopeGroupId(long scopeGroupId) {
1457                    _scopeGroupId = scopeGroupId;
1458            }
1459    
1460            @Override
1461            public void setScopeLayoutUuid(String scopeLayoutUuid) {
1462                    _scopeLayoutUuid = scopeLayoutUuid;
1463            }
1464    
1465            @Override
1466            public void setScopeType(String scopeType) {
1467                    _scopeType = scopeType;
1468            }
1469    
1470            @Override
1471            public void setSourceCompanyGroupId(long sourceCompanyGroupId) {
1472                    _sourceCompanyGroupId = sourceCompanyGroupId;
1473            }
1474    
1475            @Override
1476            public void setSourceGroupId(long sourceGroupId) {
1477                    _sourceGroupId = sourceGroupId;
1478            }
1479    
1480            @Override
1481            public void setStartDate(Date startDate) {
1482                    _startDate = startDate;
1483            }
1484    
1485            @Override
1486            public String toXML(Object object) {
1487                    return _xStream.toXML(object);
1488            }
1489    
1490            protected ServiceContext createServiceContext(
1491                    Element element, String path, ClassedModel classedModel,
1492                    String namespace) {
1493    
1494                    Class<?> clazz = classedModel.getModelClass();
1495                    long classPK = getClassPK(classedModel);
1496    
1497                    ServiceContext serviceContext = new ServiceContext();
1498    
1499                    // Theme display
1500    
1501                    serviceContext.setCompanyId(getCompanyId());
1502                    serviceContext.setScopeGroupId(getScopeGroupId());
1503    
1504                    // Dates
1505    
1506                    if (classedModel instanceof AuditedModel) {
1507                            AuditedModel auditedModel = (AuditedModel)classedModel;
1508    
1509                            serviceContext.setCreateDate(auditedModel.getCreateDate());
1510                            serviceContext.setModifiedDate(auditedModel.getModifiedDate());
1511                    }
1512    
1513                    // Permissions
1514    
1515                    if (!MapUtil.getBoolean(
1516                                    _parameterMap, PortletDataHandlerKeys.PERMISSIONS)) {
1517    
1518                            serviceContext.setAddGroupPermissions(true);
1519                            serviceContext.setAddGuestPermissions(true);
1520                    }
1521    
1522                    // Asset
1523    
1524                    boolean portletMetadataAll = getBooleanParameter(
1525                            namespace, PortletDataHandlerKeys.PORTLET_METADATA_ALL);
1526    
1527                    if (isResourceMain(classedModel)) {
1528                            if (portletMetadataAll ||
1529                                    getBooleanParameter(namespace, "categories")) {
1530    
1531                                    long[] assetCategoryIds = getAssetCategoryIds(clazz, classPK);
1532    
1533                                    serviceContext.setAssetCategoryIds(assetCategoryIds);
1534                            }
1535    
1536                            if (portletMetadataAll || getBooleanParameter(namespace, "tags")) {
1537                                    String[] assetTagNames = getAssetTagNames(clazz, classPK);
1538    
1539                                    serviceContext.setAssetTagNames(assetTagNames);
1540                            }
1541                    }
1542    
1543                    // Expando
1544    
1545                    String expandoPath = null;
1546    
1547                    if (element != null) {
1548                            expandoPath = element.attributeValue("expando-path");
1549                    }
1550                    else {
1551                            expandoPath = getExpandoPath(path);
1552                    }
1553    
1554                    if (Validator.isNotNull(expandoPath)) {
1555                            try {
1556                                    Map<String, Serializable> expandoBridgeAttributes =
1557                                            (Map<String, Serializable>)getZipEntryAsObject(expandoPath);
1558    
1559                                    serviceContext.setExpandoBridgeAttributes(
1560                                            expandoBridgeAttributes);
1561                            }
1562                            catch (Exception e) {
1563                                    if (_log.isDebugEnabled()) {
1564                                            _log.debug(e, e);
1565                                    }
1566                            }
1567                    }
1568    
1569                    return serviceContext;
1570            }
1571    
1572            protected String getActionIds_5(
1573                            long companyId, long roleId, String className, String primKey,
1574                            List<String> actionIds)
1575                    throws SystemException {
1576    
1577                    List<String> availableActionIds = new ArrayList<String>(
1578                            actionIds.size());
1579    
1580                    for (String actionId : actionIds) {
1581                            if (PermissionLocalServiceUtil.hasRolePermission(
1582                                            roleId, companyId, className,
1583                                            ResourceConstants.SCOPE_INDIVIDUAL, primKey, actionId)) {
1584    
1585                                    availableActionIds.add(actionId);
1586                            }
1587                    }
1588    
1589                    return StringUtil.merge(availableActionIds);
1590            }
1591    
1592            protected Map<Long, Set<String>> getActionIds_6(
1593                            long companyId, long[] roleIds, String className, long primKey,
1594                            List<String> actionIds)
1595                    throws PortalException, SystemException {
1596    
1597                    if (ResourceBlockLocalServiceUtil.isSupported(className)) {
1598                            return ResourceBlockPermissionLocalServiceUtil.
1599                                    getAvailableResourceBlockPermissionActionIds(
1600                                            roleIds, className, primKey, actionIds);
1601                    }
1602                    else {
1603                            return ResourcePermissionLocalServiceUtil.
1604                                    getAvailableResourcePermissionActionIds(
1605                                            companyId, className, ResourceConstants.SCOPE_INDIVIDUAL,
1606                                            String.valueOf(primKey), roleIds, actionIds);
1607                    }
1608            }
1609    
1610            protected long getClassPK(ClassedModel classedModel) {
1611                    if (classedModel instanceof ResourcedModel) {
1612                            ResourcedModel resourcedModel = (ResourcedModel)classedModel;
1613    
1614                            return resourcedModel.getResourcePrimKey();
1615                    }
1616                    else {
1617                            return (Long)classedModel.getPrimaryKeyObj();
1618                    }
1619            }
1620    
1621            protected String getExpandoPath(String path) {
1622                    if (!Validator.isFilePath(path, false)) {
1623                            throw new IllegalArgumentException(
1624                                    path + " is located outside of the lar");
1625                    }
1626    
1627                    int pos = path.lastIndexOf(".xml");
1628    
1629                    if (pos == -1) {
1630                            throw new IllegalArgumentException(
1631                                    path + " does not end with .xml");
1632                    }
1633    
1634                    return path.substring(0, pos).concat("-expando").concat(
1635                            path.substring(pos));
1636            }
1637    
1638            protected String getPrimaryKeyString(Class<?> clazz, long classPK) {
1639                    return getPrimaryKeyString(clazz.getName(), String.valueOf(classPK));
1640            }
1641    
1642            protected String getPrimaryKeyString(Class<?> clazz, String primaryKey) {
1643                    return getPrimaryKeyString(clazz.getName(), primaryKey);
1644            }
1645    
1646            protected String getPrimaryKeyString(String className, long classPK) {
1647                    return getPrimaryKeyString(className, String.valueOf(classPK));
1648            }
1649    
1650            protected String getPrimaryKeyString(String className, String primaryKey) {
1651                    return className.concat(StringPool.POUND).concat(primaryKey);
1652            }
1653    
1654            protected void initXStream() {
1655                    _xStream = new XStream();
1656    
1657                    _xStream.alias("BlogsEntry", BlogsEntryImpl.class);
1658                    _xStream.alias("BookmarksFolder", BookmarksFolderImpl.class);
1659                    _xStream.alias("BookmarksEntry", BookmarksEntryImpl.class);
1660                    _xStream.alias("CalEvent", CalEventImpl.class);
1661                    _xStream.alias("DLFolder", DLFolderImpl.class);
1662                    _xStream.alias("DLFileEntry", DLFileEntryImpl.class);
1663                    _xStream.alias("DLFileShortcut", DLFileShortcutImpl.class);
1664                    _xStream.alias("DLFileRank", DLFileRankImpl.class);
1665                    _xStream.alias("JournalArticle", JournalArticleImpl.class);
1666                    _xStream.alias("JournalFeed", JournalFeedImpl.class);
1667                    _xStream.alias("JournalStructure", JournalStructureImpl.class);
1668                    _xStream.alias("JournalTemplate", JournalTemplateImpl.class);
1669                    _xStream.alias("Lock", LockImpl.class);
1670                    _xStream.alias("MBBan", MBBanImpl.class);
1671                    _xStream.alias("MBCategory", MBCategoryImpl.class);
1672                    _xStream.alias("MBMessage", MBMessageImpl.class);
1673                    _xStream.alias("MBThreadFlag", MBThreadFlagImpl.class);
1674                    _xStream.alias("PollsQuestion", PollsQuestionImpl.class);
1675                    _xStream.alias("PollsChoice", PollsChoiceImpl.class);
1676                    _xStream.alias("PollsVote", PollsVoteImpl.class);
1677                    _xStream.alias("RatingsEntry", RatingsEntryImpl.class);
1678                    _xStream.alias("WikiNode", WikiNodeImpl.class);
1679                    _xStream.alias("WikiPage", WikiPageImpl.class);
1680    
1681                    _xStream.omitField(HashMap.class, "cache_bitmask");
1682            }
1683    
1684            protected boolean isResourceMain(ClassedModel classedModel) {
1685                    if (classedModel instanceof ResourcedModel) {
1686                            ResourcedModel resourcedModel = (ResourcedModel)classedModel;
1687    
1688                            return resourcedModel.isResourceMain();
1689                    }
1690    
1691                    return true;
1692            }
1693    
1694            protected void validateDateRange(Date startDate, Date endDate)
1695                    throws PortletDataException {
1696    
1697                    if ((startDate == null) && (endDate != null)) {
1698                            throw new PortletDataException(
1699                                    PortletDataException.END_DATE_IS_MISSING_START_DATE);
1700                    }
1701                    else if ((startDate != null) && (endDate == null)) {
1702                            throw new PortletDataException(
1703                                    PortletDataException.START_DATE_IS_MISSING_END_DATE);
1704                    }
1705    
1706                    if (startDate != null) {
1707                            if (startDate.after(endDate) || startDate.equals(endDate)) {
1708                                    throw new PortletDataException(
1709                                            PortletDataException.START_DATE_AFTER_END_DATE);
1710                            }
1711    
1712                            Date now = new Date();
1713    
1714                            if (startDate.after(now)) {
1715                                    throw new PortletDataException(
1716                                            PortletDataException.FUTURE_START_DATE);
1717                            }
1718    
1719                            if (endDate.after(now)) {
1720                                    throw new PortletDataException(
1721                                            PortletDataException.FUTURE_END_DATE);
1722                            }
1723                    }
1724            }
1725    
1726            private static Log _log = LogFactoryUtil.getLog(
1727                    PortletDataContextImpl.class);
1728    
1729            private Map<String, long[]> _assetCategoryIdsMap =
1730                    new HashMap<String, long[]>();
1731            private Map<String, String[]> _assetCategoryUuidsMap =
1732                    new HashMap<String, String[]>();
1733            private Map<String, String[]> _assetLinkUuidsMap =
1734                    new HashMap<String, String[]>();
1735            private Map<String, String[]> _assetTagNamesMap =
1736                    new HashMap<String, String[]>();
1737            private Map<String, List<MBMessage>> _commentsMap =
1738                    new HashMap<String, List<MBMessage>>();
1739            private long _companyGroupId;
1740            private long _companyId;
1741            private String _dataStrategy;
1742            private Date _endDate;
1743            private Map<String, List<ExpandoColumn>> _expandoColumnsMap =
1744                    new HashMap<String, List<ExpandoColumn>>();
1745            private long _groupId;
1746            private Map<String, Lock> _locksMap = new HashMap<String, Lock>();
1747            private Map<String, Map<?, ?>> _newPrimaryKeysMaps =
1748                    new HashMap<String, Map<?, ?>>();
1749            private Set<String> _notUniquePerLayout = new HashSet<String>();
1750            private long _oldPlid;
1751            private Map<String, String[]> _parameterMap;
1752            private Map<String, List<KeyValuePair>> _permissionsMap =
1753                    new HashMap<String, List<KeyValuePair>>();
1754            private long _plid;
1755            private PortletDataContextListener _portletDataContextListener;
1756            private Set<String> _primaryKeys;
1757            private boolean _privateLayout;
1758            private Map<String, List<RatingsEntry>> _ratingsEntriesMap =
1759                    new HashMap<String, List<RatingsEntry>>();
1760            private long _scopeGroupId;
1761            private String _scopeLayoutUuid;
1762            private String _scopeType;
1763            private long _sourceCompanyGroupId;
1764            private long _sourceGroupId;
1765            private Date _startDate;
1766            private UserIdStrategy _userIdStrategy;
1767            private XStream _xStream;
1768            private ZipReader _zipReader;
1769            private ZipWriter _zipWriter;
1770    
1771    }