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.portlet.rolesadmin.lar;
016    
017    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
018    import com.liferay.portal.kernel.dao.orm.Junction;
019    import com.liferay.portal.kernel.dao.orm.Property;
020    import com.liferay.portal.kernel.dao.orm.PropertyFactoryUtil;
021    import com.liferay.portal.kernel.dao.orm.QueryUtil;
022    import com.liferay.portal.kernel.dao.orm.RestrictionsFactoryUtil;
023    import com.liferay.portal.kernel.exception.PortalException;
024    import com.liferay.portal.kernel.exception.SystemException;
025    import com.liferay.portal.kernel.lar.BaseStagedModelDataHandler;
026    import com.liferay.portal.kernel.lar.ExportImportPathUtil;
027    import com.liferay.portal.kernel.lar.PortletDataContext;
028    import com.liferay.portal.kernel.log.Log;
029    import com.liferay.portal.kernel.log.LogFactoryUtil;
030    import com.liferay.portal.kernel.util.GetterUtil;
031    import com.liferay.portal.kernel.xml.Element;
032    import com.liferay.portal.model.Group;
033    import com.liferay.portal.model.GroupConstants;
034    import com.liferay.portal.model.Permission;
035    import com.liferay.portal.model.ResourceConstants;
036    import com.liferay.portal.model.ResourcePermission;
037    import com.liferay.portal.model.ResourceTypePermission;
038    import com.liferay.portal.model.Role;
039    import com.liferay.portal.security.permission.PermissionConversionFilter;
040    import com.liferay.portal.security.permission.PermissionConverterUtil;
041    import com.liferay.portal.service.GroupLocalServiceUtil;
042    import com.liferay.portal.service.ResourceBlockLocalServiceUtil;
043    import com.liferay.portal.service.ResourcePermissionLocalServiceUtil;
044    import com.liferay.portal.service.ResourcePermissionServiceUtil;
045    import com.liferay.portal.service.ResourceTypePermissionLocalServiceUtil;
046    import com.liferay.portal.service.RoleLocalServiceUtil;
047    import com.liferay.portal.service.ServiceContext;
048    
049    import java.util.List;
050    
051    /**
052     * @author David Mendez Gonzalez
053     * @author Michael C. Han
054     */
055    public class RoleStagedModelDataHandler
056            extends BaseStagedModelDataHandler<Role> {
057    
058            public static final String[] CLASS_NAMES = {Role.class.getName()};
059    
060            @Override
061            public void deleteStagedModel(
062                            String uuid, long groupId, String className, String extraData)
063                    throws PortalException, SystemException {
064    
065                    Group group = GroupLocalServiceUtil.getGroup(groupId);
066    
067                    Role role = RoleLocalServiceUtil.fetchRoleByUuidAndCompanyId(
068                            uuid, group.getCompanyId());
069    
070                    if (role != null) {
071                            RoleLocalServiceUtil.deleteRole(role);
072                    }
073            }
074    
075            @Override
076            public String[] getClassNames() {
077                    return CLASS_NAMES;
078            }
079    
080            @Override
081            public String getDisplayName(Role role) {
082                    return role.getName();
083            }
084    
085            protected void deleteRolePermissions(
086                            PortletDataContext portletDataContext, Role importedRole)
087                    throws SystemException {
088    
089                    List<ResourcePermission> resourcePermissions =
090                            ResourcePermissionLocalServiceUtil.getRoleResourcePermissions(
091                                    importedRole.getRoleId(),
092                                    new int[] {
093                                            ResourceConstants.SCOPE_COMPANY,
094                                            ResourceConstants.SCOPE_GROUP_TEMPLATE
095                                    },
096                                    QueryUtil.ALL_POS, QueryUtil.ALL_POS);
097    
098                    for (ResourcePermission resourcePermission : resourcePermissions) {
099                            ResourcePermissionLocalServiceUtil.deleteResourcePermission(
100                                    resourcePermission);
101                    }
102    
103                    List<ResourcePermission> groupResourcePermissions =
104                            ResourcePermissionLocalServiceUtil.getRoleResourcePermissions(
105                                    importedRole.getRoleId(),
106                                    new int[] {ResourceConstants.SCOPE_GROUP},
107                                    QueryUtil.ALL_POS, QueryUtil.ALL_POS);
108    
109                    for (ResourcePermission groupResourcePermission :
110                                    groupResourcePermissions) {
111    
112                            long groupId = GetterUtil.getLong(
113                                    groupResourcePermission.getPrimKey());
114    
115                            if ((groupId == portletDataContext.getCompanyGroupId()) ||
116                                    (groupId == portletDataContext.getUserPersonalSiteGroupId())) {
117    
118                                    ResourcePermissionLocalServiceUtil.deleteResourcePermission(
119                                            groupResourcePermission);
120                            }
121                    }
122    
123                    List<ResourceTypePermission> resourceTypePermissions =
124                            getResourceTypePermissions(portletDataContext, importedRole);
125    
126                    for (ResourceTypePermission resourceTypePermission :
127                                    resourceTypePermissions) {
128    
129                            ResourceTypePermissionLocalServiceUtil.deleteResourceTypePermission(
130                                    resourceTypePermission);
131                    }
132            }
133    
134            @Override
135            protected void doExportStagedModel(
136                            PortletDataContext portletDataContext, Role role)
137                    throws Exception {
138    
139                    String permissionsPath = ExportImportPathUtil.getModelPath(
140                            role, "permissions.xml");
141    
142                    List<Permission> permissions =
143                            PermissionConverterUtil.convertPermissions(
144                                    role, _permissionConversionFilter);
145    
146                    String xml = portletDataContext.toXML(permissions);
147    
148                    portletDataContext.addZipEntry(permissionsPath, xml);
149    
150                    Element roleElement = portletDataContext.getExportDataElement(role);
151    
152                    portletDataContext.addClassedModel(
153                            roleElement, ExportImportPathUtil.getModelPath(role), role,
154                            RolesAdminPortletDataHandler.NAMESPACE);
155            }
156    
157            @Override
158            protected void doImportStagedModel(
159                            PortletDataContext portletDataContext, Role role)
160                    throws Exception {
161    
162                    long userId = portletDataContext.getUserId(role.getUserUuid());
163    
164                    ServiceContext serviceContext = portletDataContext.createServiceContext(
165                            role, RolesAdminPortletDataHandler.NAMESPACE);
166    
167                    Role existingRole = RoleLocalServiceUtil.fetchRoleByUuidAndCompanyId(
168                            role.getUuid(), portletDataContext.getCompanyId());
169    
170                    if (existingRole == null) {
171                            existingRole = RoleLocalServiceUtil.fetchRole(
172                                    portletDataContext.getCompanyId(), role.getName());
173                    }
174    
175                    Role importedRole = null;
176    
177                    if (existingRole == null) {
178                            serviceContext.setUuid(role.getUuid());
179    
180                            importedRole = RoleLocalServiceUtil.addRole(
181                                    userId, null, 0, role.getName(), role.getTitleMap(),
182                                    role.getDescriptionMap(), role.getType(), role.getSubtype(),
183                                    serviceContext);
184                    }
185                    else {
186                            importedRole = RoleLocalServiceUtil.updateRole(
187                                    existingRole.getRoleId(), role.getName(), role.getTitleMap(),
188                                    role.getDescriptionMap(), role.getSubtype(), serviceContext);
189    
190                            deleteRolePermissions(portletDataContext, importedRole);
191                    }
192    
193                    String permissionsPath = ExportImportPathUtil.getModelPath(
194                            role, "permissions.xml");
195    
196                    List<Permission> permissions =
197                            (List<Permission>)portletDataContext.getZipEntryAsObject(
198                                    permissionsPath);
199    
200                    for (Permission permission : permissions) {
201                            if (ResourceBlockLocalServiceUtil.isSupported(
202                                            permission.getName())) {
203    
204                                    importResourceBlock(
205                                            portletDataContext, importedRole, permission);
206                            }
207                            else {
208                                    importResourcePermissions(
209                                            portletDataContext, importedRole, permission);
210                            }
211                    }
212    
213                    portletDataContext.importClassedModel(
214                            role, importedRole, RolesAdminPortletDataHandler.NAMESPACE);
215            }
216    
217            protected List<ResourceTypePermission> getResourceTypePermissions(
218                            PortletDataContext portletDataContext, Role importedRole)
219                    throws SystemException {
220    
221                    DynamicQuery dynamicQuery =
222                            ResourceTypePermissionLocalServiceUtil.dynamicQuery();
223    
224                    Property companyIdProperty = PropertyFactoryUtil.forName("companyId");
225    
226                    dynamicQuery.add(
227                            companyIdProperty.eq(portletDataContext.getCompanyId()));
228    
229                    Junction junction = RestrictionsFactoryUtil.disjunction();
230    
231                    long[] permissibleGroupIds = {
232                            GroupConstants.DEFAULT_PARENT_GROUP_ID,
233                            portletDataContext.getCompanyId(),
234                            portletDataContext.getCompanyGroupId(),
235                            portletDataContext.getUserPersonalSiteGroupId()
236                    };
237    
238                    for (long permissibleGroupId : permissibleGroupIds) {
239                            Property property = PropertyFactoryUtil.forName("groupId");
240    
241                            junction.add(property.eq(permissibleGroupId));
242                    }
243    
244                    dynamicQuery.add(junction);
245    
246                    Property roleIdProperty = PropertyFactoryUtil.forName("roleId");
247    
248                    dynamicQuery.add(roleIdProperty.eq(importedRole.getRoleId()));
249    
250                    return ResourceTypePermissionLocalServiceUtil.dynamicQuery(
251                            dynamicQuery);
252            }
253    
254            protected void importResourceBlock(
255                            PortletDataContext portletDataContext, Role importedRole,
256                            Permission permission)
257                    throws PortalException, SystemException {
258    
259                    int scope = permission.getScope();
260    
261                    if (scope == ResourceConstants.SCOPE_COMPANY) {
262                            ResourceBlockLocalServiceUtil.addCompanyScopePermission(
263                                    portletDataContext.getCompanyId(), permission.getName(),
264                                    importedRole.getRoleId(), permission.getActionId());
265                    }
266                    else if (scope == ResourceConstants.SCOPE_GROUP) {
267                            long groupId = portletDataContext.getCompanyGroupId();
268    
269                            long sourceGroupId = GetterUtil.getLong(permission.getPrimKey());
270    
271                            if (sourceGroupId ==
272                                            portletDataContext.getSourceUserPersonalSiteGroupId()) {
273    
274                                    groupId = portletDataContext.getUserPersonalSiteGroupId();
275                            }
276    
277                            ResourceBlockLocalServiceUtil.addGroupScopePermission(
278                                    portletDataContext.getCompanyId(), groupId,
279                                    permission.getName(), importedRole.getRoleId(),
280                                    permission.getActionId());
281                    }
282                    else if (scope == ResourceConstants.SCOPE_GROUP_TEMPLATE) {
283                            ResourceBlockLocalServiceUtil.addGroupScopePermission(
284                                    portletDataContext.getCompanyId(),
285                                    GroupConstants.DEFAULT_PARENT_GROUP_ID, permission.getName(),
286                                    importedRole.getRoleId(), permission.getActionId());
287                    }
288                    else {
289                            if (_log.isDebugEnabled()) {
290                                    _log.debug("Individually scoped permissions are not exported");
291                            }
292                    }
293            }
294    
295            protected void importResourcePermissions(
296                            PortletDataContext portletDataContext, Role importedRole,
297                            Permission permission)
298                    throws PortalException, SystemException {
299    
300                    int scope = permission.getScope();
301    
302                    if (scope == ResourceConstants.SCOPE_COMPANY) {
303                            ResourcePermissionServiceUtil.addResourcePermission(
304                                    portletDataContext.getCompanyGroupId(),
305                                    portletDataContext.getCompanyId(), permission.getName(), scope,
306                                    String.valueOf(portletDataContext.getCompanyGroupId()),
307                                    importedRole.getRoleId(), permission.getActionId());
308                    }
309                    else if (scope == ResourceConstants.SCOPE_GROUP) {
310                            long groupId = portletDataContext.getCompanyGroupId();
311    
312                            long sourceGroupId = GetterUtil.getLong(permission.getPrimKey());
313    
314                            if (sourceGroupId ==
315                                            portletDataContext.getSourceUserPersonalSiteGroupId()) {
316    
317                                    groupId = portletDataContext.getUserPersonalSiteGroupId();
318                            }
319    
320                            ResourcePermissionServiceUtil.addResourcePermission(
321                                    groupId, portletDataContext.getCompanyId(),
322                                    permission.getName(), ResourceConstants.SCOPE_GROUP,
323                                    String.valueOf(groupId), importedRole.getRoleId(),
324                                    permission.getActionId());
325                    }
326                    else if (scope == ResourceConstants.SCOPE_GROUP_TEMPLATE) {
327                            ResourcePermissionServiceUtil.addResourcePermission(
328                                    GroupConstants.DEFAULT_PARENT_GROUP_ID,
329                                    portletDataContext.getCompanyId(), permission.getName(),
330                                    ResourceConstants.SCOPE_GROUP_TEMPLATE,
331                                    String.valueOf(GroupConstants.DEFAULT_PARENT_GROUP_ID),
332                                    importedRole.getRoleId(), permission.getActionId());
333                    }
334                    else {
335                            if (_log.isDebugEnabled()) {
336                                    _log.debug("Individually scoped permissions are not imported");
337                            }
338                    }
339            }
340    
341            private static Log _log = LogFactoryUtil.getLog(
342                    RoleStagedModelDataHandler.class);
343    
344            private PermissionConversionFilter _permissionConversionFilter =
345                    new ImportExportPermissionConversionFilter();
346    
347    }