LibreCCM
/
libreccm
3
0
Fork 0
Code Issues 10 Pull Requests Packages Releases Wiki Activity

Some fixes for import

deploy_packages_to_gitea
Jens Pelzetter 2023-01-12 19:01:03 +01:00
parent 3a9a065f50
commit 610b050ac5
8 changed files with 99 additions and 264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
ccm-core/src/main/java/org/libreccm/categorization/CategorizationImExporter.java
View File

@ -41,7 +41,6 @@ import javax.persistence.NoResultException;
public class CategorizationImExporter
extends AbstractEntityImExporter<Categorization> {
@Inject
private CategorizationRepository categoriationRepo;
@ -68,6 +67,11 @@ public class CategorizationImExporter
return categoriationRepo.findByUuid(uuid);
}
@Override
protected void saveImportedEntity(final Categorization entity) {
entityManager.merge(entity);
}
@Override
protected void updateExistingEntity(
final Categorization existingEntity, final Categorization importedEntity
@ -95,21 +99,16 @@ public class CategorizationImExporter
.getCategoryOrder()) {
existingEntity.setCategoryOrder(importedEntity.getCategoryOrder());
}
if (existingEntity.getObjectOrder() != importedEntity.getObjectOrder()) {
existingEntity.setObjectOrder(importedEntity.getObjectOrder());
}
if (!Objects.equals(existingEntity.getType(), importedEntity.getType())) {
existingEntity.setType(importedEntity.getType());
}
entityManager.merge(existingEntity);
}
@Override
protected void saveImportedEntity(final Categorization entity) {
entityManager.merge(entity);
entityManager.merge(existingEntity);
}
@Override

44
ccm-core/src/main/java/org/libreccm/categorization/CategoryImExporter.java
View File

@ -119,32 +119,6 @@ public class CategoryImExporter extends AbstractEntityImExporter<Category> {
existingEntity.setName(importedEntity.getName());
}
if (!Objects.equals(
existingEntity.getObjects(),
importedEntity.getObjects()
)) {
final Set<Categorization> categorizationsToRemove = existingEntity
.getObjects()
.stream()
.filter(
categorization -> !importedEntity.getObjects().contains(
categorization
)
)
.collect(Collectors.toSet());
for (Categorization toRemove : categorizationsToRemove) {
try {
categoryManager.removeObjectFromCategory(
toRemove.getCategorizedObject(),
existingEntity
);
} catch (ObjectNotAssignedToCategoryException ex) {
throw new UnexpectedErrorException(ex);
}
}
}
if (!Objects.equals(
existingEntity.getParentCategory(),
importedEntity.getParentCategory()
@ -169,24 +143,18 @@ public class CategoryImExporter extends AbstractEntityImExporter<Category> {
existingEntity.getSubCategories(),
importedEntity.getSubCategories()
)) {
final Set<Category> subCategoriesToRemove = existingEntity
final Set<Category> subCategoriesToAdd = importedEntity
.getSubCategories()
.stream()
.filter(
subCat -> !importedEntity.getSubCategories().contains(
subCat
category -> !existingEntity.getSubCategories().contains(
category
)
)
.collect(Collectors.toSet());
for (final Category toRemove : subCategoriesToRemove) {
try {
categoryManager.removeObjectFromCategory(
toRemove, existingEntity
);
} catch (ObjectNotAssignedToCategoryException ex) {
throw new UnexpectedErrorException(ex);
}
for(final Category category : subCategoriesToAdd) {
existingEntity.addSubCategory(category);
}
}

23
ccm-core/src/main/java/org/libreccm/categorization/DomainImExporter.java
View File

@ -98,13 +98,10 @@ public class DomainImExporter extends AbstractEntityImExporter<Domain> {
existingEntity.getDescription(),
importedEntity.getDescription()
)) {
for (final Map.Entry<Locale, String> entry : importedEntity
.getDescription().getValues().entrySet()) {
syncLocalizedStrings(
importedEntity.getDescription(),
existingEntity.getDescription()
);
}
syncLocalizedStrings(
importedEntity.getDescription(),
existingEntity.getDescription()
);
}
if (!Objects.equals(
@ -130,18 +127,6 @@ public class DomainImExporter extends AbstractEntityImExporter<Domain> {
.stream()
.filter(owner -> !existingEntity.getOwners().contains(owner))
.collect(Collectors.toSet());
final Set<DomainOwnership> ownersToRemove = existingEntity
.getOwners()
.stream()
.filter(owner -> !importedEntity.getOwners().contains(owner))
.collect(Collectors.toSet());
for (final DomainOwnership toRemove : ownersToRemove) {
domainManager.removeDomainOwner(
toRemove.getOwner(),
existingEntity
);
}
for (final DomainOwnership toAdd : ownersToAdd) {
domainManager.addDomainOwner(toAdd.getOwner(),

40
ccm-core/src/main/java/org/libreccm/security/GroupImExporter.java
View File

@ -23,8 +23,6 @@ import org.libreccm.imexport.Processes;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import javax.annotation.PostConstruct;
import javax.enterprise.context.RequestScoped;
@ -83,44 +81,6 @@ public class GroupImExporter extends AbstractEntityImExporter<Group> {
existingEntity.setName(importedEntity.getName());
}
if (!Objects.equals(
existingEntity.getMemberships(),
importedEntity.getMemberships()
)) {
final Set<GroupMembership> membershipsToRemove = existingEntity
.getMemberships()
.stream()
.filter(
membership -> !importedEntity.getMemberships().contains(
membership
)
)
.collect(Collectors.toSet());
final Set<GroupMembership> membershipsToAdd = importedEntity
.getMemberships()
.stream()
.filter(
membership -> !existingEntity.getMemberships().contains(
membership
)
)
.collect(Collectors.toSet());
for (final GroupMembership membership : membershipsToRemove) {
groupManager.removeMemberFromGroup(
membership.getMember(),
existingEntity
);
}
for(final GroupMembership membership: membershipsToAdd) {
groupManager.addMemberToGroup(
membership.getMember(),
existingEntity
);
}
}
groupRepository.save(existingEntity);
}

43
ccm-core/src/main/java/org/libreccm/security/GroupMembershipImExporter.java
View File

@ -40,6 +40,9 @@ import javax.persistence.NoResultException;
public class GroupMembershipImExporter
extends AbstractEntityImExporter<GroupMembership> {
@Inject
private GroupManager groupManager;
@Inject
private GroupMembershipRepository groupMembershipRepo;
@ -80,7 +83,45 @@ public class GroupMembershipImExporter
final GroupMembership existingEntity,
final GroupMembership importedEntity
) {
// No update, update is handled by GroupImporter
if (!Objects.equals(
existingEntity.getGroup(),
importedEntity.getGroup()
) && !Objects.equals(
existingEntity.getMember(),
importedEntity.getMember()
)) {
final Group oldGroup = existingEntity.getGroup();
final User oldMember = existingEntity.getMember();
final Group newGroup = importedEntity.getGroup();
final User newMember = importedEntity.getMember();
groupManager.removeMemberFromGroup(oldMember, oldGroup);
groupManager.addMemberToGroup(newMember, newGroup);
}
if (!Objects.equals(
existingEntity.getGroup(),
importedEntity.getGroup()
)) {
final Group oldGroup = existingEntity.getGroup();
final Group newGroup = importedEntity.getGroup();
final User member = existingEntity.getMember();
groupManager.removeMemberFromGroup(member, oldGroup);
groupManager.addMemberToGroup(member, newGroup);
}
if (!Objects.equals(
existingEntity.getMember(),
importedEntity.getMember()
)) {
final User oldMember = existingEntity.getMember();
final User newMember = importedEntity.getMember();
final Group group = existingEntity.getGroup();
groupManager.removeMemberFromGroup(oldMember, group);
groupManager.addMemberToGroup(newMember, group);
}
}
@Override

124
ccm-core/src/main/java/org/libreccm/security/RoleImExporter.java
View File

@ -127,130 +127,6 @@ public class RoleImExporter extends AbstractEntityImExporter<Role> {
}
roleRepository.save(existingEntity);
if (!Objects.equals(
existingEntity.getMemberships(),
importedEntity.getMemberships()
)) {
final Set<RoleMembership> membershipsToRemove = existingEntity
.getMemberships()
.stream()
.filter(
membership -> !importedEntity.getMemberships().contains(
membership
)
).collect(Collectors.toSet());
final Set<RoleMembership> membershipsToAdd = importedEntity
.getMemberships()
.stream()
.filter(
membership -> !existingEntity.getMemberships().contains(
membership
)
)
.collect(Collectors.toSet());
for (final RoleMembership membership : membershipsToRemove) {
roleManager.removeRoleFromParty(
existingEntity,
membership.getMember()
);
}
for (final RoleMembership membership : membershipsToAdd) {
roleManager.assignRoleToParty(
existingEntity,
membership.getMember()
);
}
}
if (!Objects.equals(
existingEntity.getPermissions(),
importedEntity.getPermissions()
)) {
final Set<Permission> permissionsToRemove = existingEntity
.getPermissions()
.stream()
.filter(
permission -> !importedEntity.getPermissions().contains(
permission
)
)
.collect(Collectors.toSet());
final Set<Permission> permissionToAdd = importedEntity
.getPermissions()
.stream()
.filter(
permission -> !existingEntity.getPermissions().contains(
permission
)
).collect(Collectors.toSet());
for (final Permission permission : permissionsToRemove) {
if (permission.getObject() == null) {
permissionManager.revokePrivilege(
permission.getGrantedPrivilege(),
existingEntity
);
} else {
permissionManager.revokePrivilege(
permission.getGrantedPrivilege(),
existingEntity,
permission.getObject()
);
}
}
for (final Permission permission : permissionToAdd) {
if (permission.getObject() == null) {
permissionManager.grantPrivilege(
permission.getGrantedPrivilege(),
existingEntity
);
} else {
permissionManager.grantPrivilege(
permission.getGrantedPrivilege(),
existingEntity,
permission.getObject()
);
}
}
}
if (!Objects.equals(
existingEntity.getAssignedTasks(),
importedEntity.getAssignedTasks()
)) {
final Set<TaskAssignment> assignmentsToRemove = existingEntity
.getAssignedTasks()
.stream()
.filter(
assignment -> !importedEntity.getAssignedTasks().contains(
assignment
)
)
.collect(Collectors.toSet());
final Set<TaskAssignment> assignmentsToAdd = importedEntity
.getAssignedTasks()
.stream()
.filter(
assignment -> !existingEntity.getAssignedTasks().contains(
assignment
)
)
.collect(Collectors.toSet());
for(final TaskAssignment assignment : assignmentsToRemove) {
taskManager.retractTask(assignment.getTask(), existingEntity);
}
for(final TaskAssignment assignment : assignmentsToAdd) {
taskManager.assignTask(assignment.getTask(), existingEntity);
}
}
}
@Override

21
ccm-core/src/main/java/org/libreccm/security/RoleMembershipImExporter.java
View File

@ -41,7 +41,7 @@ public class RoleMembershipImExporter
@Inject
private EntityManager entityManager;
@Inject
private RoleMembershipRepository membershipRepo;
@ -61,7 +61,7 @@ public class RoleMembershipImExporter
public Class<RoleMembership> getEntityClass() {
return RoleMembership.class;
}
@Override
protected Optional<RoleMembership> findExistingEntity(final String uuid) {
return membershipRepo.findByUuid(uuid);
@ -76,13 +76,26 @@ public class RoleMembershipImExporter
entityManager.merge(entity);
}
}
@Override
protected void updateExistingEntity(
final RoleMembership existingEntity,
final RoleMembership importedEntity
) {
// Nothing
if (!Objects.equals(
existingEntity.getRole(),
importedEntity.getRole()
)) {
existingEntity.setRole(importedEntity.getRole());
}
if (!Objects.equals(
existingEntity.getMember(),
importedEntity.getMember()
)) {
existingEntity.setMember(importedEntity.getMember());
}
membershipRepo.save(existingEntity);
}
@Override

51
ccm-core/src/main/java/org/libreccm/workflow/WorkflowImExporter.java
View File

@ -41,7 +41,7 @@ public class WorkflowImExporter extends AbstractEntityImExporter<Workflow> {
@Inject
private TaskManager taskManager;
@Inject
private WorkflowRepository workflowRepository;
@ -55,7 +55,7 @@ public class WorkflowImExporter extends AbstractEntityImExporter<Workflow> {
public Class<Workflow> getEntityClass() {
return Workflow.class;
}
@Override
protected Optional<Workflow> findExistingEntity(final String uuid) {
return workflowRepository.findByUuid(uuid);
@ -71,85 +71,78 @@ public class WorkflowImExporter extends AbstractEntityImExporter<Workflow> {
final Workflow existingEntity,
final Workflow importedEntity
) {
if (existingEntity.isAbstractWorkflow() != importedEntity.isAbstractWorkflow()) {
if (existingEntity.isAbstractWorkflow() != importedEntity
.isAbstractWorkflow()) {
existingEntity.setAbstractWorkflow(
importedEntity.isAbstractWorkflow()
);
}
if (!Objects.equals(
existingEntity.getTemplate(),
importedEntity.getTemplate()
)) {
existingEntity.setTemplate(importedEntity.getTemplate());
}
if (!Objects.equals(
existingEntity.getName(),
existingEntity.getName(),
importedEntity.getName()
)) {
syncLocalizedStrings(
importedEntity.getName(),
importedEntity.getName(),
existingEntity.getName()
);
}
if (!Objects.equals(
existingEntity.getDescription(),
existingEntity.getDescription(),
importedEntity.getDescription()
)) {
syncLocalizedStrings(
importedEntity.getDescription(),
importedEntity.getDescription(),
existingEntity.getDescription()
);
}
if (existingEntity.getState() != importedEntity.getState()) {
existingEntity.setState(importedEntity.getState());
}
if (existingEntity.isActive() != importedEntity.isActive()) {
existingEntity.setActive(importedEntity.isActive());
}
if (existingEntity.getTasksState() != importedEntity.getTasksState()) {
existingEntity.setTasksState(importedEntity.getTasksState());
}
if (!Objects.equals(
existingEntity.getObject(),
importedEntity.getObject()
)) {
existingEntity.setObject(importedEntity.getObject());
}
workflowRepository.save(importedEntity);
if (!Objects.equals(
existingEntity.getTasks(),
importedEntity.getTasks()
)) {
final Set<Task> tasksToRemove = existingEntity
.getTasks()
.stream()
.filter(task -> !importedEntity.getTasks().contains(task))
.collect(Collectors.toSet());
final Set<Task> tasksToAdd = importedEntity
.getTasks()
.stream( )
.stream()
.filter(task -> !existingEntity.getTasks().contains(task))
.collect(Collectors.toSet());
for(final Task task : tasksToRemove) {
taskManager.removeTask(existingEntity, task);
}
for(final Task task : tasksToAdd) {
for (final Task task : tasksToAdd) {
taskManager.addTask(existingEntity, task);
}
}
}
@Override
protected Workflow reloadEntity(final Workflow entity) {
return workflowRepository