Server-side implementation to support group owner updates in the

sailing hierarchy
This commit is contained in:
Steffen Schäfer committed 2018-11-21 15:52:37 +01:00
1 parent ba83102e1b
commit bc5c8baa6b
9 files changed
+338

No files matched your search

@@ -950,4 +950,10 @@ public interface SailingService extends RemoteService, FileStorageManagementGwtS
void setDefaultTenantForCurrentServer(String tennant);
List<String> 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);
}
@@ -1049,4 +1049,10 @@ public interface SailingServiceAsync extends ServerInfoRetriever, FileStorageMan
* gets a (possibly imcomplete) list of available tennants to choose from.
*/
void getPossibleTennants(AsyncCallback<List<String>> asyncCallback);
void updateGroupOwnerForEventHierarchy(UUID eventId, UUID newGroupOwnerId, String newGroupNameToCreate,
boolean updateCompetitors, boolean updateBoats, AsyncCallback<Void> callback);
void updateGroupOwnerForLeaderboardGroupHierarchy(UUID leaderboardGroupId, UUID newGroupOwnerId,
String newGroupNameToCreate, boolean updateCompetitors, boolean updateBoats, AsyncCallback<Void> callback);
}
@@ -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);
}
}
@@ -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,
@@ -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<LeaderboardGroup> leaderboardGroups);
}
@@ -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);
}
@@ -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);
}
@@ -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<QualifiedObjectIdentifier> 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<LeaderboardGroup> 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);
}
}
}
@@ -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<Leaderboard, Set<LeaderboardGroup>> 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<Leaderboard, Set<LeaderboardGroup>> 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);
}
}
}