diff --git a/java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/SailingService.java b/java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/SailingService.java index fdf83cde886..3476ed3d3c1 100755 --- a/java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/SailingService.java +++ b/java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/SailingService.java @@ -950,4 +950,10 @@ public interface SailingService extends RemoteService, FileStorageManagementGwtS void setDefaultTenantForCurrentServer(String tennant); List getPossibleTennants(); + + void updateGroupOwnerForEventHierarchy(UUID eventId, UUID newGroupOwnerId, String newGroupNameToCreate, + boolean updateCompetitors, boolean updateBoats); + + void updateGroupOwnerForLeaderboardGroupHierarchy(UUID leaderboardGroupId, UUID newGroupOwnerId, + String newGroupNameToCreate, boolean updateCompetitors, boolean updateBoats); } diff --git a/java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/SailingServiceAsync.java b/java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/SailingServiceAsync.java index e3dc5feb54a..bc844511a05 100755 --- a/java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/SailingServiceAsync.java +++ b/java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/SailingServiceAsync.java @@ -1049,4 +1049,10 @@ public interface SailingServiceAsync extends ServerInfoRetriever, FileStorageMan * gets a (possibly imcomplete) list of available tennants to choose from. */ void getPossibleTennants(AsyncCallback> asyncCallback); + + void updateGroupOwnerForEventHierarchy(UUID eventId, UUID newGroupOwnerId, String newGroupNameToCreate, + boolean updateCompetitors, boolean updateBoats, AsyncCallback callback); + + void updateGroupOwnerForLeaderboardGroupHierarchy(UUID leaderboardGroupId, UUID newGroupOwnerId, + String newGroupNameToCreate, boolean updateCompetitors, boolean updateBoats, AsyncCallback callback); } diff --git a/java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/server/SailingServiceImpl.java b/java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/server/SailingServiceImpl.java index 83d9c49be87..7b4d176f7ed 100755 --- a/java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/server/SailingServiceImpl.java +++ b/java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/server/SailingServiceImpl.java @@ -469,6 +469,8 @@ import com.sap.sailing.manage2sail.RegattaResultDescriptor; import com.sap.sailing.resultimport.ResultUrlProvider; import com.sap.sailing.resultimport.ResultUrlRegistry; import com.sap.sailing.server.RacingEventService; +import com.sap.sailing.server.hierarchy.SailingHierarchyOwnershipUpdater; +import com.sap.sailing.server.hierarchy.SailingHierarchyOwnershipUpdater.GroupOwnerUpdateStrategy; import com.sap.sailing.server.masterdata.MasterDataImporter; import com.sap.sailing.server.operationaltransformation.AddColumnToLeaderboard; import com.sap.sailing.server.operationaltransformation.AddColumnToSeries; @@ -591,10 +593,13 @@ import com.sap.sse.security.ActionWithResult; import com.sap.sse.security.SecurityService; import com.sap.sse.security.SessionUtils; import com.sap.sse.security.shared.HasPermissions.DefaultActions; +import com.sap.sse.security.shared.OwnershipAnnotation; +import com.sap.sse.security.shared.QualifiedObjectIdentifier; import com.sap.sse.security.shared.RoleDefinition; import com.sap.sse.security.shared.RoleImpl; import com.sap.sse.security.shared.User; import com.sap.sse.security.shared.UserGroup; +import com.sap.sse.security.shared.UserGroupManagementException; import com.sap.sse.security.shared.WildcardPermission; import com.sap.sse.security.shared.impl.SecuredSecurityTypes; import com.sap.sse.security.shared.impl.SecuredSecurityTypes.ServerActions; @@ -8547,4 +8552,73 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S } return result; } + + @Override + public void updateGroupOwnerForEventHierarchy(UUID eventId, UUID newGroupOwnerId, String newGroupNameToCreate, boolean updateCompetitors, + boolean updateBoats) { + Event event = getService().getEvent(eventId); + UserGroup groupOwnerToSet = getSecurityService().getUserGroup(newGroupOwnerId); + if (event != null && groupOwnerToSet != null) { + createOwnershipUpdater(newGroupOwnerId, newGroupNameToCreate, updateCompetitors, + updateBoats).updateGroupOwnershipForEventHierarchy(event); + } + } + + @Override + public void updateGroupOwnerForLeaderboardGroupHierarchy(UUID leaderboardGroupId, UUID newGroupOwnerId, String newGroupNameToCreate, + boolean updateCompetitors, boolean updateBoats) { + LeaderboardGroup leaderboardGroup = getService().getLeaderboardGroupByID(leaderboardGroupId); + UserGroup groupOwnerToSet = getSecurityService().getUserGroup(newGroupOwnerId); + if (leaderboardGroup != null && groupOwnerToSet != null) { + createOwnershipUpdater(newGroupOwnerId, newGroupNameToCreate, updateCompetitors, + updateBoats).updateGroupOwnershipForLeaderboardGroupHierarchy(leaderboardGroup); + } + } + + private SailingHierarchyOwnershipUpdater createOwnershipUpdater( UUID newGroupOwnerId, String newGroupNameToCreate, boolean updateCompetitors, + boolean updateBoats) { + final GroupOwnerUpdateStrategy updateStrategy; + if (newGroupOwnerId != null) { + final UserGroup groupOwnerToSet = getSecurityService().getUserGroup(newGroupOwnerId); + if (groupOwnerToSet == null) { + throw new RuntimeException("User group does not exist"); + } + updateStrategy = new GroupOwnerUpdateStrategy() { + @Override + public boolean needsUpdate(QualifiedObjectIdentifier identifier, OwnershipAnnotation currentOwnership) { + return currentOwnership == null || !groupOwnerToSet.equals(currentOwnership.getAnnotation().getTenantOwner()); + } + + @Override + public UserGroup getNewGroupOwner() { + return groupOwnerToSet; + } + }; + } else if (newGroupNameToCreate != null && ! newGroupNameToCreate.isEmpty()) { + updateStrategy = new GroupOwnerUpdateStrategy() { + private UserGroup groupOwnerToSet; + + @Override + public boolean needsUpdate(QualifiedObjectIdentifier identifier, OwnershipAnnotation currentOwnership) { + return true; + } + + @Override + public UserGroup getNewGroupOwner() { + if (groupOwnerToSet != null) { + try { + groupOwnerToSet = getSecurityService().createUserGroup(UUID.randomUUID(), newGroupNameToCreate); + } catch (UserGroupManagementException e) { + throw new RuntimeException("Could not create user group"); + } + } + return groupOwnerToSet; + } + }; + } else { + throw new RuntimeException("No user group given"); + } + return new SailingHierarchyOwnershipUpdater(getService(), getSecurityService(), updateStrategy, updateCompetitors, + updateBoats); + } } diff --git a/java/com.sap.sailing.server/META-INF/MANIFEST.MF b/java/com.sap.sailing.server/META-INF/MANIFEST.MF index dccd1cf792a..25a26cd5c53 100644 --- a/java/com.sap.sailing.server/META-INF/MANIFEST.MF +++ b/java/com.sap.sailing.server/META-INF/MANIFEST.MF @@ -43,6 +43,7 @@ Require-Bundle: com.sap.sailing.domain, com.sap.sse.security.common Bundle-ClassPath: . Export-Package: com.sap.sailing.server, + com.sap.sailing.server.hierarchy, com.sap.sailing.server.impl; x-friends:="com.sap.sailing.mongodb.test, com.sap.sailing.server.test, diff --git a/java/com.sap.sailing.server/src/com/sap/sailing/server/hierarchy/EventHierarchyVisitor.java b/java/com.sap.sailing.server/src/com/sap/sailing/server/hierarchy/EventHierarchyVisitor.java new file mode 100644 index 00000000000..a5803126f10 --- /dev/null +++ b/java/com.sap.sailing.server/src/com/sap/sailing/server/hierarchy/EventHierarchyVisitor.java @@ -0,0 +1,13 @@ +package com.sap.sailing.server.hierarchy; + +import java.util.Set; + +import com.sap.sailing.domain.leaderboard.Leaderboard; +import com.sap.sailing.domain.leaderboard.LeaderboardGroup; + +public interface EventHierarchyVisitor { + + void visit(LeaderboardGroup leaderboardGroup); + + void visit(Leaderboard leaderboard, Set leaderboardGroups); +} diff --git a/java/com.sap.sailing.server/src/com/sap/sailing/server/hierarchy/LeaderboardGroupHierarchyVisitor.java b/java/com.sap.sailing.server/src/com/sap/sailing/server/hierarchy/LeaderboardGroupHierarchyVisitor.java new file mode 100644 index 00000000000..8b9a249ae68 --- /dev/null +++ b/java/com.sap.sailing.server/src/com/sap/sailing/server/hierarchy/LeaderboardGroupHierarchyVisitor.java @@ -0,0 +1,11 @@ +package com.sap.sailing.server.hierarchy; + +import com.sap.sailing.domain.base.Event; +import com.sap.sailing.domain.leaderboard.Leaderboard; + +public interface LeaderboardGroupHierarchyVisitor { + + void visit(Event event); + + void visit(Leaderboard leaderboard); +} diff --git a/java/com.sap.sailing.server/src/com/sap/sailing/server/hierarchy/LeaderboardHierarchyVisitor.java b/java/com.sap.sailing.server/src/com/sap/sailing/server/hierarchy/LeaderboardHierarchyVisitor.java new file mode 100644 index 00000000000..2d034248936 --- /dev/null +++ b/java/com.sap.sailing.server/src/com/sap/sailing/server/hierarchy/LeaderboardHierarchyVisitor.java @@ -0,0 +1,15 @@ +package com.sap.sailing.server.hierarchy; + +import com.sap.sailing.domain.base.Boat; +import com.sap.sailing.domain.base.Competitor; +import com.sap.sailing.domain.tracking.TrackedRace; + +public interface LeaderboardHierarchyVisitor { + + void visit(TrackedRace race); + + void visit(Competitor competitor); + + void visit(Boat boat); + +} diff --git a/java/com.sap.sailing.server/src/com/sap/sailing/server/hierarchy/SailingHierarchyOwnershipUpdater.java b/java/com.sap.sailing.server/src/com/sap/sailing/server/hierarchy/SailingHierarchyOwnershipUpdater.java new file mode 100644 index 00000000000..20f9e1f7f57 --- /dev/null +++ b/java/com.sap.sailing.server/src/com/sap/sailing/server/hierarchy/SailingHierarchyOwnershipUpdater.java @@ -0,0 +1,138 @@ +package com.sap.sailing.server.hierarchy; + +import java.util.HashSet; +import java.util.Set; + +import org.apache.shiro.SecurityUtils; + +import com.sap.sailing.domain.base.Boat; +import com.sap.sailing.domain.base.Competitor; +import com.sap.sailing.domain.base.Event; +import com.sap.sailing.domain.leaderboard.Leaderboard; +import com.sap.sailing.domain.leaderboard.LeaderboardGroup; +import com.sap.sailing.domain.tracking.TrackedRace; +import com.sap.sailing.server.RacingEventService; +import com.sap.sse.security.SecurityService; +import com.sap.sse.security.shared.HasPermissions.DefaultActions; +import com.sap.sse.security.shared.OwnershipAnnotation; +import com.sap.sse.security.shared.QualifiedObjectIdentifier; +import com.sap.sse.security.shared.User; +import com.sap.sse.security.shared.UserGroup; +import com.sap.sse.security.shared.WildcardPermission; + +/** + * Encapsulates the logic to ensure consistency of group owners in the sailing domain object hierarchy. + */ +public class SailingHierarchyOwnershipUpdater { + + public interface GroupOwnerUpdateStrategy { + boolean needsUpdate(QualifiedObjectIdentifier identifier, OwnershipAnnotation currentOwnership); + + UserGroup getNewGroupOwner(); + } + + private final RacingEventService service; + private final SecurityService securityService; + private final GroupOwnerUpdateStrategy updateStrategy; + private final boolean updateCompetitors; + private final boolean updateBoats; + private final Set objectsToUpdateOwnershipsFor; + + public SailingHierarchyOwnershipUpdater(final RacingEventService service, SecurityService securityService, + final GroupOwnerUpdateStrategy updateStrategy, final boolean updateCompetitors, final boolean updateBoats) { + this.service = service; + this.securityService = securityService; + this.updateStrategy = updateStrategy; + this.updateCompetitors = updateCompetitors; + this.updateBoats = updateBoats; + objectsToUpdateOwnershipsFor = new HashSet<>(); + } + + public void updateGroupOwnershipForEventHierarchy(Event event) { + updateGroupOwnershipForEventHierarchyInternal(event); + commitChanges(); + } + + private void updateGroupOwnershipForEventHierarchyInternal(Event event) { + updateGroupOwner(event.getIdentifier()); + SailingHierarchyWalker.walkFromEvent(event, false, new EventHierarchyVisitor() { + @Override + public void visit(Leaderboard leaderboard, Set leaderboardGroups) { + updateGroupOwnershipForLeaderboardHierarchy(leaderboard); + } + + @Override + public void visit(LeaderboardGroup leaderboardGroup) { + // No LeaderboardGroups with overall leaderboard are visited -> no infinite recursion occurs + updateGroupOwnershipForLeaderboardGroupHierarchyInternal(leaderboardGroup); + } + }); + } + + public void updateGroupOwnershipForLeaderboardGroupHierarchy(LeaderboardGroup leaderboardGroup) { + updateGroupOwnershipForLeaderboardGroupHierarchyInternal(leaderboardGroup); + commitChanges(); + } + + public void updateGroupOwnershipForLeaderboardGroupHierarchyInternal(LeaderboardGroup leaderboardGroup) { + updateGroupOwner(leaderboardGroup.getIdentifier()); + SailingHierarchyWalker.walkFromLeaderboardGroup(service, leaderboardGroup, true, + new LeaderboardGroupHierarchyVisitor() { + @Override + public void visit(Leaderboard leaderboard) { + updateGroupOwnershipForLeaderboardHierarchy(leaderboard); + } + + @Override + public void visit(Event event) { + // Only events of LeaderboardGroups with overall leaderboard are visited -> no infinite + // recursion occurs + updateGroupOwnershipForEventHierarchyInternal(event); + } + }); + } + + public void updateGroupOwnershipForLeaderboardHierarchy(Leaderboard leaderboard) { + updateGroupOwner(leaderboard.getIdentifier()); + SailingHierarchyWalker.walkFromLeaderboard(leaderboard, new LeaderboardHierarchyVisitor() { + @Override + public void visit(TrackedRace race) { + updateGroupOwner(race.getIdentifier()); + } + + @Override + public void visit(Boat boat) { + if (updateBoats) { + updateGroupOwner(boat.getIdentifier()); + } + } + + @Override + public void visit(Competitor competitor) { + if (updateCompetitors) { + updateGroupOwner(competitor.getIdentifier()); + } + } + }); + } + + private void updateGroupOwner(QualifiedObjectIdentifier id) { + final OwnershipAnnotation ownership = securityService.getOwnership(id); + if (updateStrategy.needsUpdate(id, ownership)) { + String permissionToCheck = id.getTypeIdentifier() + WildcardPermission.PART_DIVIDER_TOKEN + + DefaultActions.CHANGE_OWNERSHIP.name() + WildcardPermission.PART_DIVIDER_TOKEN + + id.getTypeRelativeObjectIdentifier(); + SecurityUtils.getSubject().checkPermission(permissionToCheck); + objectsToUpdateOwnershipsFor.add(id); + } + } + + private void commitChanges() { + final UserGroup groupOwnerToSet = updateStrategy.getNewGroupOwner(); + for (QualifiedObjectIdentifier id : objectsToUpdateOwnershipsFor) { + final OwnershipAnnotation ownership = securityService.getOwnership(id); + securityService.setOwnership(id, ownership == null ? null : (User) ownership.getAnnotation().getUserOwner(), + groupOwnerToSet); + } + } +} diff --git a/java/com.sap.sailing.server/src/com/sap/sailing/server/hierarchy/SailingHierarchyWalker.java b/java/com.sap.sailing.server/src/com/sap/sailing/server/hierarchy/SailingHierarchyWalker.java new file mode 100644 index 00000000000..c3ba44e0242 --- /dev/null +++ b/java/com.sap.sailing.server/src/com/sap/sailing/server/hierarchy/SailingHierarchyWalker.java @@ -0,0 +1,74 @@ +package com.sap.sailing.server.hierarchy; + +import java.util.HashMap; +import java.util.Map; +import java.util.Set; + +import com.sap.sailing.domain.base.Boat; +import com.sap.sailing.domain.base.Competitor; +import com.sap.sailing.domain.base.Event; +import com.sap.sailing.domain.leaderboard.Leaderboard; +import com.sap.sailing.domain.leaderboard.LeaderboardGroup; +import com.sap.sailing.domain.tracking.TrackedRace; +import com.sap.sailing.server.RacingEventService; +import com.sap.sse.common.Util; + +/** + * Util to walk the sailing domain object hierarchy using visitors. This util encapsulates specific hierarchy logic + * necessary because the hierarchy is not always obvious and consistent. For event series, the {@link LeaderboardGroup} + * is meant to be the top level domain object and defines a hierarchy containing several {@link Event Events} and + * {@link Leaderboard Leaderboards}. For other event types, the {@link LeaderboardGroup} is only a related object of the + * {@link Event} defining the top level point of a hierarchy. + */ +public final class SailingHierarchyWalker { + + private SailingHierarchyWalker() { + } + + public static void walkFromEvent(final Event event, final boolean includeLeaderboardGroupsWithOverallLeaderboard, + final EventHierarchyVisitor visitor) { + final Map> leaderboardsToLeaderboardGroups = new HashMap<>(); + for (LeaderboardGroup lg : event.getLeaderboardGroups()) { + if (includeLeaderboardGroupsWithOverallLeaderboard || !lg.hasOverallLeaderboard()) { + visitor.visit(lg); + } + for (Leaderboard lb : lg.getLeaderboards()) { + Util.add(leaderboardsToLeaderboardGroups, lb, lg); + } + } + for (Map.Entry> entry : leaderboardsToLeaderboardGroups.entrySet()) { + visitor.visit(entry.getKey(), entry.getValue()); + } + } + + public static void walkFromLeaderboardGroup(RacingEventService service, final LeaderboardGroup leaderboardGroup, + final boolean includeEventsIfLeaderboardGroupHasOverallLeaderboard, + final LeaderboardGroupHierarchyVisitor visitor) { + boolean visitEvents = includeEventsIfLeaderboardGroupHasOverallLeaderboard + && leaderboardGroup.hasOverallLeaderboard(); + + if (visitEvents) { + for (Event event : service.getAllEvents()) { + if (Util.contains(event.getLeaderboardGroups(), leaderboardGroup)) { + visitor.visit(event); + } + } + } + + for (Leaderboard lb : leaderboardGroup.getLeaderboards()) { + visitor.visit(lb); + } + } + + public static void walkFromLeaderboard(final Leaderboard leaderboard, final LeaderboardHierarchyVisitor visitor) { + for (TrackedRace race : leaderboard.getTrackedRaces()) { + visitor.visit(race); + } + for (Competitor comp : leaderboard.getCompetitors()) { + visitor.visit(comp); + } + for (Boat boat : leaderboard.getAllBoats()) { + visitor.visit(boat); + } + } +}