org.bonitasoft.engine.identity.xml.ImportOrganization Maven / Gradle / Ivy
/**
* Copyright (C) 2012-2013 BonitaSoft S.A.
* BonitaSoft, 32 rue Gustave Eiffel - 38000 Grenoble
* This library is free software; you can redistribute it and/or modify it under the terms
* of the GNU Lesser General Public License as published by the Free Software Foundation
* version 2.1 of the License.
* This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
* You should have received a copy of the GNU Lesser General Public License along with this
* program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
* Floor, Boston, MA 02110-1301, USA.
**/
package org.bonitasoft.engine.identity.xml;
import java.io.Serializable;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.bonitasoft.engine.commons.transaction.TransactionContentWithResult;
import org.bonitasoft.engine.identity.ExportedUser;
import org.bonitasoft.engine.identity.GroupCreator;
import org.bonitasoft.engine.identity.GroupCreator.GroupField;
import org.bonitasoft.engine.identity.IdentityService;
import org.bonitasoft.engine.identity.ImportPolicy;
import org.bonitasoft.engine.identity.OrganizationImportException;
import org.bonitasoft.engine.identity.RoleCreator;
import org.bonitasoft.engine.identity.RoleCreator.RoleField;
import org.bonitasoft.engine.identity.SGroupCreationException;
import org.bonitasoft.engine.identity.SGroupNotFoundException;
import org.bonitasoft.engine.identity.SIdentityException;
import org.bonitasoft.engine.identity.SRoleNotFoundException;
import org.bonitasoft.engine.identity.SUserCreationException;
import org.bonitasoft.engine.identity.SUserMembershipCreationException;
import org.bonitasoft.engine.identity.SUserNotFoundException;
import org.bonitasoft.engine.identity.SUserUpdateException;
import org.bonitasoft.engine.identity.UserMembership;
import org.bonitasoft.engine.identity.model.SContactInfo;
import org.bonitasoft.engine.identity.model.SGroup;
import org.bonitasoft.engine.identity.model.SRole;
import org.bonitasoft.engine.identity.model.SUser;
import org.bonitasoft.engine.identity.model.SUserMembership;
import org.bonitasoft.engine.identity.model.builder.IdentityModelBuilder;
import org.bonitasoft.engine.identity.model.builder.UserUpdateBuilder;
import org.bonitasoft.engine.log.technical.TechnicalLogSeverity;
import org.bonitasoft.engine.log.technical.TechnicalLoggerService;
import org.bonitasoft.engine.service.ModelConvertor;
import org.bonitasoft.engine.service.TenantServiceAccessor;
import org.bonitasoft.engine.xml.Parser;
/**
* @author Matthieu Chaffotte
*/
public class ImportOrganization implements TransactionContentWithResult> {
final IdentityService identityService;
final IdentityModelBuilder identityModelBuilder;
private final Parser parser;
private final TechnicalLoggerService logger;
private final String organizationContent;
private final List warnings;
private final ImportOrganizationStrategy strategy;
public ImportOrganization(final TenantServiceAccessor serviceAccessor, final String organizationContent, final ImportPolicy policy)
throws OrganizationImportException {
identityService = serviceAccessor.getIdentityService();
this.organizationContent = organizationContent;
identityModelBuilder = serviceAccessor.getIdentityModelBuilder();
parser = serviceAccessor.getParserFactgory().createParser(OrganizationNodeBuilder.BINDINGS);
logger = serviceAccessor.getTechnicalLoggerService();
warnings = new ArrayList();
switch (policy) {
case FAIL_ON_DUPLICATES:
strategy = new ImportOrganizationFailOnDuplicatesStrategy();
break;
case IGNORE_DUPLICATES:
strategy = new ImportOrganizationIgnoreDuplicatesStrategy();
break;
case MERGE_DUPLICATES:
strategy = new ImportOrganizationMergeDuplicatesStrategy(identityService, identityModelBuilder);
break;
default:
throw new OrganizationImportException("No import strategy found for " + policy);
}
}
@Override
public List getResult() {
return warnings;
}
@Override
public void execute() throws ImportDuplicateInOrganizationException {
importOrganizationWithDuplicates();
}
private void importOrganizationWithDuplicates() throws ImportDuplicateInOrganizationException {
try {
parser.setSchema(this.getClass().getResourceAsStream("/bos-organization.xsd"));
parser.validate(new StringReader(organizationContent));
final Organization organization = (Organization) parser.getObjectFromXML(new StringReader(organizationContent));
final List users = organization.getUsers();
final List roles = organization.getRoles();
final List groups = organization.getGroups();
final List memberships = organization.getMemberships();
// Users
final Map userNameToSUsers = importUsers(users);
updateManagerId(users, userNameToSUsers);
// Roles
final Map roleNameToIdMap = importRoles(roles);
// Groups
final Map groupPathToIdMap = importGroups(groups);
// UserMemberships
importMemberships(memberships, userNameToSUsers, roleNameToIdMap, groupPathToIdMap);
} catch (final Exception e) {
throw new ImportDuplicateInOrganizationException(e);
}
}
private void importMemberships(final List memberships, final Map userNameToSUsers, final Map roleNameToIdMap,
final Map groupPathToIdMap) throws SIdentityException, ImportDuplicateInOrganizationException {
for (final UserMembership newMembership : memberships) {
final Long userId = getUserId(userNameToSUsers, newMembership);
final Long groupId = getGroupId(groupPathToIdMap, newMembership);
final Long roleId = getRoleId(roleNameToIdMap, newMembership);
if (userId != null && groupId != null && roleId != null) {
try {
final SUserMembership sUserMembership = identityService.getUserMembership(userId, groupId, roleId);
strategy.foundExistingMembership(sUserMembership);
} catch (final SIdentityException e) {
final Long assignedBy = getAssignedBy(userNameToSUsers, newMembership);
addMembership(newMembership, userId, groupId, roleId, assignedBy);
}
} else {
if (logger.isLoggable(getClass(), TechnicalLogSeverity.WARNING)) {
logger.log(getClass(), TechnicalLogSeverity.WARNING, "The membership " + newMembership
+ " because the user group or role can't be found\n userId=" + userId + " groupId=" + groupId + " roleId=" + roleId);
}
}
}
}
private Long getUserId(final Map userNameToSUsers, final UserMembership newMembership) {
final String username = newMembership.getUsername();
if (username == null || username.isEmpty()) {
return -1L;
} else {
final SUser sUser = userNameToSUsers.get(username);
if (sUser != null) {
return sUser.getId();
} else {
return null;
}
}
}
private Long getGroupId(final Map groupPathToIdMap, final UserMembership newMembership) {
final String groupParentPath = newMembership.getGroupParentPath();
final String groupFullPath = (groupParentPath == null ? '/' : groupParentPath + '/') + newMembership.getGroupName();
return groupPathToIdMap.get(groupFullPath);
}
private Long getRoleId(final Map roleNameToIdMap, final UserMembership newMembership) {
final String roleName = newMembership.getRoleName();
if (roleName == null || roleName.isEmpty()) {
return -1L;
} else {
final Long roleId = roleNameToIdMap.get(roleName);
if (roleId != null) {
return roleId;
} else {
return null;
}
}
}
private Long getAssignedBy(final Map userNameToSUsers, final UserMembership newMembership) {
final String assignedByName = newMembership.getAssignedByName();
if (assignedByName == null || assignedByName.isEmpty()) {
return -1L;
} else {
final SUser sUserAssigned = userNameToSUsers.get(assignedByName);
if (sUserAssigned != null) {
return sUserAssigned.getId();
} else {
return -1L;
}
}
}
private Map importGroups(final List groupCreators) throws ImportDuplicateInOrganizationException,
SIdentityException {
final Map groupPathToIdMap = new HashMap(groupCreators.size());
for (final GroupCreator groupCreator : groupCreators) {
SGroup sGroup;
try {
final String groupPath = getGroupPath(groupCreator);
sGroup = identityService.getGroupByPath(groupPath);
strategy.foundExistingGroup(sGroup, groupCreator);
} catch (final SGroupNotFoundException e) {
sGroup = addGroup(groupCreator);
}
groupPathToIdMap.put(sGroup.getPath(), sGroup.getId());
}
return groupPathToIdMap;
}
private String getGroupPath(final GroupCreator creator) {
final Map fields = creator.getFields();
final String name = (String) fields.get(GroupField.NAME);
final String parentPath = (String) fields.get(GroupField.PARENT_PATH);
if (parentPath == null) {
return "/" + name;
} else {
return parentPath + "/" + name;
}
}
private Map importRoles(final List roleCreators) throws ImportDuplicateInOrganizationException,
SIdentityException {
final Map roleNameToIdMap = new HashMap(roleCreators.size());
for (final RoleCreator roleCreator : roleCreators) {
SRole sRole;
try {
sRole = identityService.getRoleByName((String) roleCreator.getFields().get(RoleField.NAME));
strategy.foundExistingRole(sRole, roleCreator);
} catch (final SRoleNotFoundException e) {
sRole = addRole(roleCreator);
}
roleNameToIdMap.put(sRole.getName(), sRole.getId());
}
return roleNameToIdMap;
}
private void updateManagerId(final List users, final Map userNameToSUsers)
throws SUserUpdateException {
for (final ExportedUser user : users) {
final String managerUserName = user.getManagerUserName();
if (managerUserName != null && managerUserName.trim().length() > 0 && userNameToSUsers.get(managerUserName) != null) {
final SUser sUser = userNameToSUsers.get(user.getUserName());
final Long managerId = userNameToSUsers.get(managerUserName).getId();
if (managerId != null) {
final UserUpdateBuilder userUpdateBuilder = identityModelBuilder.getUserUpdateBuilder();
identityService.updateUser(sUser, userUpdateBuilder.updateManagerUserId(managerId).done());
} else {
if (logger.isLoggable(getClass(), TechnicalLogSeverity.WARNING)) {
logger.log(this.getClass(), TechnicalLogSeverity.WARNING, "The user " + user.getUserName() + " has a manager with username "
+ managerUserName + " but this one does not exist, Please set it manually");
}
}
}
}
}
private Map importUsers(final List users)
throws ImportDuplicateInOrganizationException, SIdentityException {
final Map userNameToSUsers = new HashMap((int) Math.min(Integer.MAX_VALUE, identityService.getNumberOfUsers()));
for (final ExportedUser user : users) {
SUser sUser;
try {
sUser = identityService.getUserByUserName(user.getUserName());
strategy.foundExistingUser(sUser, user);
} catch (final SUserNotFoundException e) {
sUser = addUser(user);
}
userNameToSUsers.put(sUser.getUserName(), sUser);
}
return userNameToSUsers;
}
private void addMembership(final UserMembership newMembership, final Long userId, final Long groupId, final Long roleId, final Long assignedBy)
throws SUserMembershipCreationException {
final long assignedDateAsLong = getAssignedDate(newMembership);
final SUserMembership sUserMembership = identityModelBuilder.getUserMembershipBuilder().createNewInstance(userId, groupId, roleId)
.setAssignedBy(assignedBy).setAssignedDate(assignedDateAsLong).done();
identityService.createUserMembership(sUserMembership);
}
private long getAssignedDate(final UserMembership newMembership) {
final Date assignedDate = newMembership.getAssignedDate();
if (assignedDate != null) {
return assignedDate.getTime();
} else {
return 0;
}
}
private SGroup addGroup(final GroupCreator creator) throws SGroupCreationException {
final SGroup sGroup = ModelConvertor.constructSGroup(creator, identityModelBuilder);
identityService.createGroup(sGroup);
return sGroup;
}
private SRole addRole(final RoleCreator creator) throws SIdentityException {
final SRole sRole = ModelConvertor.constructSRole(creator, identityModelBuilder);
identityService.createRole(sRole);
return sRole;
}
private SUser addUser(final ExportedUser user) throws SUserCreationException, SUserUpdateException {
SUser sUser;
if (user.isPasswordEncrypted()) {
sUser = identityService.createUserWithoutEncryptingPassword(ModelConvertor.constructSUser(user, identityModelBuilder));
} else {
sUser = identityService.createUser(ModelConvertor.constructSUser(user, identityModelBuilder));
}
final SContactInfo persoSContactInfo = ModelConvertor.constructSUserContactInfo(user, true, identityModelBuilder, sUser.getId());
identityService.createUserContactInfo(persoSContactInfo);
final SContactInfo professSContactInfo = ModelConvertor.constructSUserContactInfo(user, false, identityModelBuilder, sUser.getId());
identityService.createUserContactInfo(professSContactInfo);
return sUser;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy