diff --git a/java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/coursetemplate/MarkPropertiesBasedMarkConfiguration.java b/java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/coursetemplate/MarkPropertiesBasedMarkConfiguration.java
index 322848603de..61121ee3ba5 100755
--- a/java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/coursetemplate/MarkPropertiesBasedMarkConfiguration.java
+++ b/java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/coursetemplate/MarkPropertiesBasedMarkConfiguration.java
@@ -1,23 +1,20 @@
package com.sap.sailing.domain.coursetemplate;
/**
- * Configures a mark based on a {@link MarkProperties} object returned from {@link #getMarkProperties()}. Optionally, a
- * non-{@code null} {@link MarkTemplate} may be returned from {@link #getOptionalMarkTemplate()} which then means that the mark
- * to create and configure assumes the "role" defined by the mark template. The {@link MarkProperties} attributes,
- * if present, take precedence over their respective {@link MarkTemplate} counterparts.
+ * Configures a mark based on a {@link MarkProperties} object returned from {@link #getOptionalMarkProperties()}.
+ * Optionally, a non-{@code null} {@link MarkTemplate} may be returned from {@link #getOptionalMarkTemplate()} which
+ * then means that the mark to create and configure assumes the "role" defined by the mark template. The
+ * {@link MarkProperties} attributes, if present, take precedence over their respective {@link MarkTemplate}
+ * counterparts.
*
* @author Axel Uhl (D043530)
*
*/
public interface MarkPropertiesBasedMarkConfiguration
extends MarkConfiguration
{
- MarkProperties getMarkProperties();
-
/**
- * The "optional" {@link MarkProperties} for this type of mark configuration are the {@link #getMarkProperties()
- * MarkProperties} referenced by this object and hence never {@code null}.
+ * The "optional" {@link MarkProperties} for this type of mark configuration are the {@link MarkProperties}
+ * referenced by this object and hence never {@code null}.
*/
@Override
- default MarkProperties getOptionalMarkProperties() {
- return getMarkProperties();
- }
+ MarkProperties getOptionalMarkProperties();
}
diff --git a/java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/coursetemplate/MarkTemplate.java b/java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/coursetemplate/MarkTemplate.java
index e57d9b04821..5f0308fb047 100755
--- a/java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/coursetemplate/MarkTemplate.java
+++ b/java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/coursetemplate/MarkTemplate.java
@@ -24,7 +24,6 @@ import com.sap.sse.security.shared.WithQualifiedObjectIdentifier;
public interface MarkTemplate extends ControlPointTemplate, NamedWithUUID, CommonMarkProperties,
WithQualifiedObjectIdentifier, IsManagedByCache {
public interface MarkTemplateResolver {
-
MarkTemplate getOrCreate(MarkTemplate markTemplate);
}
diff --git a/java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/coursetemplate/RegattaMarkConfiguration.java b/java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/coursetemplate/RegattaMarkConfiguration.java
index eac72cbad37..ed4d8bb6df3 100755
--- a/java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/coursetemplate/RegattaMarkConfiguration.java
+++ b/java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/coursetemplate/RegattaMarkConfiguration.java
@@ -10,9 +10,11 @@ import com.sap.sailing.domain.base.Mark;
*
*
* An optional non-{@code null} {@link MarkTemplate} may be returned from {@link #getOptionalMarkTemplate()} which then
- * leads to recording a usage relation between the regatta {@link Mark} and said {@link MarkTemplate}.
+ * leads to recording a usage relation between the regatta {@link Mark} and said {@link MarkTemplate}. This relation can be
+ * requested using {@link Mark#getOriginatingMarkTemplateIdOrNull()}.
* {@link #getOptionalMarkProperties()} can reference a {@link MarkProperties} object if the {@link #getMark mark} was
- * originally created from that {@link MarkProperties} object.
+ * originally created from that {@link MarkProperties} object. Again, the resulting usage relation can be requested using
+ * {@link Mark#getOriginatingMarkPropertiesIdOrNull()}.
*
*
* The {@link #getEffectiveProperties() effective properties} will contain
diff --git a/java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/coursetemplate/TrackingDeviceBasedPositioningWithLastKnownPosition.java b/java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/coursetemplate/TrackingDeviceBasedPositioningWithLastKnownPosition.java
new file mode 100755
index 00000000000..bb896d253c5
--- /dev/null
+++ b/java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/coursetemplate/TrackingDeviceBasedPositioningWithLastKnownPosition.java
@@ -0,0 +1,12 @@
+package com.sap.sailing.domain.coursetemplate;
+
+import com.sap.sailing.domain.common.Position;
+
+public interface TrackingDeviceBasedPositioningWithLastKnownPosition extends TrackingDeviceBasedPositioning {
+ Position getLastKnownPosition();
+
+ @Override
+ default T accept(PositioningVisitor visitor) {
+ return visitor.visit(this);
+ }
+}
diff --git a/java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/coursetemplate/impl/MarkPropertiesBasedMarkConfigurationImpl.java b/java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/coursetemplate/impl/MarkPropertiesBasedMarkConfigurationImpl.java
index 8c4e76cb488..4b97789368d 100644
--- a/java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/coursetemplate/impl/MarkPropertiesBasedMarkConfigurationImpl.java
+++ b/java/com.sap.sailing.domain.shared.android/src/com/sap/sailing/domain/coursetemplate/impl/MarkPropertiesBasedMarkConfigurationImpl.java
@@ -27,7 +27,7 @@ public class MarkPropertiesBasedMarkConfigurationImpl extends MarkConfigurati
}
@Override
- public MarkProperties getMarkProperties() {
+ public MarkProperties getOptionalMarkProperties() {
return markProperties;
}
diff --git a/java/com.sap.sailing.domain/src/com/sap/sailing/domain/sharedsailingdata/SharedSailingData.java b/java/com.sap.sailing.domain/src/com/sap/sailing/domain/sharedsailingdata/SharedSailingData.java
index 9105b3e7383..7ad11af5bde 100644
--- a/java/com.sap.sailing.domain/src/com/sap/sailing/domain/sharedsailingdata/SharedSailingData.java
+++ b/java/com.sap.sailing.domain/src/com/sap/sailing/domain/sharedsailingdata/SharedSailingData.java
@@ -10,6 +10,7 @@ import com.sap.sailing.domain.common.DeviceIdentifier;
import com.sap.sailing.domain.common.Position;
import com.sap.sailing.domain.coursetemplate.CommonMarkProperties;
import com.sap.sailing.domain.coursetemplate.CourseTemplate;
+import com.sap.sailing.domain.coursetemplate.FixedPositioning;
import com.sap.sailing.domain.coursetemplate.MarkProperties;
import com.sap.sailing.domain.coursetemplate.MarkRole;
import com.sap.sailing.domain.coursetemplate.MarkTemplate;
@@ -65,6 +66,13 @@ public interface SharedSailingData {
MarkProperties updateMarkProperties(UUID uuid, CommonMarkProperties properties, Iterable tags);
+ /**
+ * @param positioningInformation
+ * if {@code null}, no update will be performed to the positioning information of the
+ * {@link MarkProperties} object identified by {@code uuid}. To clear the positioning information, pass
+ * in a valid, non-{@code null} {@link Positioning} object that makes an "empty" specification, such as a
+ * {@link FixedPositioning} with a {@code null} {@link FixedPositioning#getFixedPosition()} return.
+ */
MarkProperties updateMarkProperties(UUID uuid, CommonMarkProperties properties, Positioning positioningInformation, Iterable tags);
/**
diff --git a/java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/deserialization/impl/CourseConfigurationBuilder.java b/java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/deserialization/impl/CourseConfigurationBuilder.java
index 172165ae5cc..80b82b2e843 100644
--- a/java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/deserialization/impl/CourseConfigurationBuilder.java
+++ b/java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/deserialization/impl/CourseConfigurationBuilder.java
@@ -182,7 +182,7 @@ public class CourseConfigurationBuilder {
public MarkConfiguration addRegattaMarkConfiguration(UUID markID, Positioning optionalPositioning,
boolean storeToInventory) {
if (optionalRegatta == null) {
- throw new IllegalStateException();
+ throw new IllegalStateException("Require a valid regatta in CourseConfigurationBuilder to add regatta mark with ID "+markID);
}
for (RaceColumn raceColumn : optionalRegatta.getRaceColumns()) {
for (Mark mark : raceColumn.getAvailableMarks()) {
@@ -308,6 +308,14 @@ public class CourseConfigurationBuilder {
return bestMatchingDeviceMapping;
}
+ /**
+ * For a {@link MarkProperties} object finds its {@link MarkProperties#getPositioningInformation()} and if it is {@code null}, returns {@code null};
+ * otherwise, for a fixed position specification that position will be returned as the "last known position" and no device ID will be returned in this
+ * case, although practically, the fixed position at some point may be stored in a regatta context using a "PING" device mapping.
+ *
+ * For device identifier-based positioning requests the device identifier will be returned and a query for the last known position of that device will
+ * be launched using the {@code positionResolver}. If a last known position is found that way, it is included in the return value of this method.
+ */
public static MarkConfigurationResponseAnnotation getPositioningIfAvailable(MarkProperties markProperties, Function positionResolver) {
final MarkConfigurationResponseAnnotation result;
final Positioning positioning = markProperties.getPositioningInformation();
diff --git a/java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/serialization/impl/CourseConfigurationJsonSerializer.java b/java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/serialization/impl/CourseConfigurationJsonSerializer.java
index 957ba57da50..53802dbcb8f 100644
--- a/java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/serialization/impl/CourseConfigurationJsonSerializer.java
+++ b/java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/serialization/impl/CourseConfigurationJsonSerializer.java
@@ -93,6 +93,7 @@ public class CourseConfigurationJsonSerializer implements JsonSerializer freeStyleMarkConfiguration =
(FreestyleMarkConfiguration) markConfiguration;
@@ -107,7 +108,7 @@ public class CourseConfigurationJsonSerializer implements JsonSerializer markPropertiesBasedMarkConfiguration =
(MarkPropertiesBasedMarkConfiguration) markConfiguration;
markConfigurationsEntry.put(FIELD_MARK_CONFIGURATION_MARK_PROPERTIES_ID,
- markPropertiesBasedMarkConfiguration.getMarkProperties().getId().toString());
+ markPropertiesBasedMarkConfiguration.getOptionalMarkProperties().getId().toString());
if (markPropertiesBasedMarkConfiguration.getOptionalMarkTemplate() != null) {
markConfigurationsEntry.put(FIELD_MARK_CONFIGURATION_MARK_TEMPLATE_ID,
markPropertiesBasedMarkConfiguration.getOptionalMarkTemplate().getId().toString());
diff --git a/java/com.sap.sailing.server.gateway/src/com/sap/sailing/server/gateway/jaxrs/api/CourseConfigurationResource.java b/java/com.sap.sailing.server.gateway/src/com/sap/sailing/server/gateway/jaxrs/api/CourseConfigurationResource.java
index e8646f1a6df..65675ccc360 100644
--- a/java/com.sap.sailing.server.gateway/src/com/sap/sailing/server/gateway/jaxrs/api/CourseConfigurationResource.java
+++ b/java/com.sap.sailing.server.gateway/src/com/sap/sailing/server/gateway/jaxrs/api/CourseConfigurationResource.java
@@ -238,8 +238,8 @@ public class CourseConfigurationResource extends AbstractSailingServerResource {
public Response createCourse(@PathParam("regattaName") String regattaName,
@QueryParam("markPropertiesGroupOwnership") String markPropertiesGroupOwnership,
@PathParam("raceColumn") String raceColumn, @PathParam("fleet") String fleet,
- String json) throws Exception {
- if (json == null || json.isEmpty()) {
+ String jsonCourseConfiguration) throws Exception {
+ if (jsonCourseConfiguration == null || jsonCourseConfiguration.isEmpty()) {
return getBadCourseConfigurationValidationErrorResponse(
"Course configuration is required to be given as json object");
}
@@ -257,7 +257,7 @@ public class CourseConfigurationResource extends AbstractSailingServerResource {
if (raceColumnByName == null || fleetByName == null) {
return getBadRaceErrorResponse(regattaName, raceColumn, fleet);
}
- final Object parsedObject = new JSONParser().parse(json);
+ final Object parsedObject = new JSONParser().parse(jsonCourseConfiguration);
if (parsedObject == null || !(parsedObject instanceof JSONObject)) {
getBadCourseConfigurationValidationErrorResponse(
"Course configuration is required to be given as json object");
diff --git a/java/com.sap.sailing.server.gateway/webservices/api/v1/courseConfigurationCreateCourseTemplate.html b/java/com.sap.sailing.server.gateway/webservices/api/v1/courseConfigurationCreateCourseTemplate.html
index c418e8632f3..a5ac74f27d1 100644
--- a/java/com.sap.sailing.server.gateway/webservices/api/v1/courseConfigurationCreateCourseTemplate.html
+++ b/java/com.sap.sailing.server.gateway/webservices/api/v1/courseConfigurationCreateCourseTemplate.html
@@ -49,7 +49,6 @@
pattern: For marks with BUOY type, this may be specified as CHECKERED
- positioning (optional): Not implemented yet!
positioning (optional): Any given positioning is only included in the resulting course configuration. As mark templates can't have positioning information attached this is not saved when creating a mark template. Because the resulting course configuration may be used to update the UI state, the positioning is included in the updated mark configurations. Either of the following properties may be given:
- deviceUUID: defines a smartphone tracking device by its UUID
diff --git a/java/com.sap.sailing.server.interface/src/com/sap/sailing/server/interfaces/CourseAndMarkConfigurationFactory.java b/java/com.sap.sailing.server.interface/src/com/sap/sailing/server/interfaces/CourseAndMarkConfigurationFactory.java
index 0258dcf8abd..a70f34e9a74 100644
--- a/java/com.sap.sailing.server.interface/src/com/sap/sailing/server/interfaces/CourseAndMarkConfigurationFactory.java
+++ b/java/com.sap.sailing.server.interface/src/com/sap/sailing/server/interfaces/CourseAndMarkConfigurationFactory.java
@@ -21,6 +21,7 @@ import com.sap.sailing.domain.coursetemplate.MarkConfigurationRequestAnnotation;
import com.sap.sailing.domain.coursetemplate.MarkConfigurationResponseAnnotation;
import com.sap.sailing.domain.coursetemplate.MarkProperties;
import com.sap.sailing.domain.coursetemplate.MarkTemplate;
+import com.sap.sailing.domain.coursetemplate.MarkTemplateBasedMarkConfiguration;
import com.sap.sailing.domain.coursetemplate.RepeatablePart;
import com.sap.sailing.domain.coursetemplate.WaypointTemplate;
import com.sap.sailing.domain.coursetemplate.WaypointWithMarkConfiguration;
@@ -62,14 +63,14 @@ public interface CourseAndMarkConfigurationFactory {
/**
* The {@link CourseConfiguration} contains everything required to produce a new {@link CourseTemplate} from it: the
* {@link MarkTemplate}s can be obtained by mapping all {@link CourseConfiguration#getAllMarks() mark
- * configurations} through {@link #getOrCreateMarkTemplate(MarkConfiguration)}. The
+ * configurations} through {@link MarkConfiguration#getOptionalMarkTemplate()}. The {@link MarkConfiguration} objects
+ * contained in the result course configuration will all be of type {@link MarkTemplateBasedMarkConfiguration}. The
* {@link WithOptionalRepeatablePart repeatable part specification} is obtained immediately from the
* {@link CourseConfiguration}. For each {@link CourseConfiguration#getWaypoints() waypoint configuration} of the
* {@code courseWithMarkConfiguration}, a {@link WaypointTemplate} is created where the {@link MarkTemplate}s
* referenced by these {@link WaypointTemplates} are those obtained by
- * {@link #getOrCreateMarkTemplate(MarkConfiguration)} for the respective {@link MarkConfiguration} objects used in
+ * {@link MarkConfiguration#getOptionalMarkTemplate()} for the respective {@link MarkConfiguration} objects used in
* the {@link WaypointWithMarkConfiguration} objects.
- * @param optionalNonDefaultGroupOwnership TODO
*
* @return a course with its mark configurations and a {@link CourseTemplate} returned by
* {@link CourseConfiguration#getOptionalCourseTemplate()} that is always valid, never {@code null}. All
@@ -111,14 +112,17 @@ public interface CourseAndMarkConfigurationFactory {
/**
* Creates a {@link CourseConfiguration} for a Regatta - either based on a {@link CourseBase} or independently. The
* resulting waypoint sequence is consistent with the one defined in the {@link CourseBase}, if one is given. In
- * case, no {@link CourseBase} is given, no waypoint sequence is constructed but existing {@link Mark}s of the
- * {@link Regatta} are loaded as {@link MarkConfiguration}s.
+ * case no {@link CourseBase} is given, no waypoint sequence is constructed but existing {@link Mark}s of the
+ * {@link Regatta} are loaded as {@link MarkConfiguration}s. All {@link MarkConfiguration} objects contained
+ * in the result will be of type {@link RegattaMarkConfiguration} as they all have been obtained from respective
+ * {@link Mark} objects that exist in the {@link Regatta}.
*
* If a given {@link CourseBase} is based on a {@link CourseTemplate}
* ({@link CourseBase#getOriginatingCourseTemplateIdOrNull() references an existing and visible CourseTemplate} and
* the waypoint sequences are compatible, the sequence is mapped back to the {@link CourseTemplate} instead of just
* loading the {@link CourseBase}. This means, if a {@link CourseBase} was created for a {@link CourseTemplate}
- * having a {@link RepeatablePart}, the lap count is reconstructed and the shortened waypoint sequence is used.
+ * having a {@link RepeatablePart}, the lap count is reconstructed and the shortened waypoint sequence is used.
+ * TODO Really? What if during the second lap a different mark was used for the windward mark's role "1"?
*
* If no {@link CourseTemplate} can be obtained or the waypoint sequences aren't compatible, the
* {@link CourseTemplate} is just ignored. No lap count and {@link RepeatablePart} is recognized and the whole
diff --git a/java/com.sap.sailing.server/src/com/sap/sailing/server/impl/CourseAndMarkConfigurationFactoryImpl.java b/java/com.sap.sailing.server/src/com/sap/sailing/server/impl/CourseAndMarkConfigurationFactoryImpl.java
index bfb62b1ac31..2545b05ab75 100644
--- a/java/com.sap.sailing.server/src/com/sap/sailing/server/impl/CourseAndMarkConfigurationFactoryImpl.java
+++ b/java/com.sap.sailing.server/src/com/sap/sailing/server/impl/CourseAndMarkConfigurationFactoryImpl.java
@@ -72,7 +72,6 @@ import com.sap.sailing.domain.coursetemplate.Positioning;
import com.sap.sailing.domain.coursetemplate.PositioningVisitor;
import com.sap.sailing.domain.coursetemplate.RegattaMarkConfiguration;
import com.sap.sailing.domain.coursetemplate.RepeatablePart;
-import com.sap.sailing.domain.coursetemplate.SmartphoneUUIDPositioning;
import com.sap.sailing.domain.coursetemplate.TrackingDeviceBasedPositioning;
import com.sap.sailing.domain.coursetemplate.TrackingDeviceBasedPositioningWithLastKnownPosition;
import com.sap.sailing.domain.coursetemplate.WaypointTemplate;
@@ -91,7 +90,6 @@ import com.sap.sailing.domain.racelog.tracking.SensorFixStore;
import com.sap.sailing.domain.racelogtracking.DeviceMappingWithRegattaLogEvent;
import com.sap.sailing.domain.racelogtracking.PingDeviceIdentifier;
import com.sap.sailing.domain.racelogtracking.impl.PingDeviceIdentifierImpl;
-import com.sap.sailing.domain.racelogtracking.impl.SmartphoneUUIDIdentifierImpl;
import com.sap.sailing.domain.sharedsailingdata.SharedSailingData;
import com.sap.sailing.domain.tracking.TrackedRace;
import com.sap.sailing.server.gateway.deserialization.impl.CourseConfigurationBuilder;
@@ -104,10 +102,19 @@ import com.sap.sse.security.shared.impl.UserGroup;
public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfigurationFactory {
- private static final Logger log = Logger.getLogger(CourseAndMarkConfigurationFactoryImpl.class.getName());
+ private static final Logger logger = Logger.getLogger(CourseAndMarkConfigurationFactoryImpl.class.getName());
private final ServiceTracker sharedSailingDataTracker;
private final SensorFixStore sensorFixStore;
+
+ /**
+ * Obtains a "last known position" for a {@link DeviceIdentifier}.
+ *
+ * FIXME The current implementation is broken in several ways: the {@link SensorFixStore} employed here does not
+ * exist in a replica, so valid results can be obtained only on a master instance which is bad. Furthermore, at least
+ * with the current implementation, queries of this type can take a long time to complete, especially when posed
+ * to the archive server.
+ */
private final Function lastKnownPositionResolver;
private final RaceLogResolver raceLogResolver;
private final DomainFactory domainFactory;
@@ -120,6 +127,8 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
this.sensorFixStore = sensorFixStore;
this.raceLogResolver = raceLogResolver;
lastKnownPositionResolver = identifier -> {
+ // FIXME see above; doesn't work on replicas due to lack of valid DB, and can take a long time especially on the archive server
+ // TODO could as well return the GPSFix object which conveniently would combine the position with the time point which may also be interesting to clients...
Position lastPosition = null;
try {
final Map lastFix = sensorFixStore.getLastFix(Collections.singleton(identifier));
@@ -128,7 +137,7 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
lastPosition = ((GPSFix) t).getPosition();
}
} catch (TransformationException | NoCorrespondingServiceRegisteredException e) {
- log.log(Level.WARNING, "Could not load associated fix for device " + identifier, e);
+ logger.log(Level.WARNING, "Could not load associated fix for device " + identifier, e);
}
return lastPosition;
};
@@ -161,25 +170,48 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
return result;
}
+ /**
+ * For all {@link MarkConfiguration} objects contained in the {@code courseConfiguration} that have
+ * {@link MarkConfiguration#getAnnotationInfo()}.{@link MarkConfigurationRequestAnnotation#isStoreToInventory()
+ * isStoreToInventory()}{@code ==true}, a create/update for a {@link MarkProperties} object is performed.
+ *
+ *
+ * If saving to the inventory is requested for a {@link MarkConfiguration} then if the requested
+ * {@link MarkConfiguration} is a {@link RegattaMarkConfiguration} (requesting that an existing {@link Mark} in a
+ * regatta be used), a corresponding {@link RegattaMarkConfiguration} is returned in the resulting course
+ * configuration that has its {@link MarkConfiguration#getOptionalMarkProperties()} set to the
+ * {@link MarkProperties} created for the regatta mark. If saving to inventory was request for any other type of
+ * mark configuration, the mark configuration will be replaced in the result by a
+ * {@link MarkPropertiesBasedMarkConfiguration} that references the {@link MarkProperties} object created or updated
+ * based on the request.
+ * TODO What is this replacement good for?
+ *
+ * @param optionalNonDefaultGroupOwnership
+ * in case {@link MarkProperties} objects have to be created then this parameter can be used to specify
+ * their group owner which otherwise will default to the calling subject user's default creation group
+ * for the server / replica set on which this request is executed.
+ */
private CourseConfigurationWithMarkRoles handleSaveToInventory(
CourseConfiguration courseConfiguration,
Optional optionalNonDefaultGroupOwnership) {
final Map, MarkConfiguration> effectiveConfigurations = new HashMap<>();
- for (MarkConfiguration markConfiguration : courseConfiguration
- .getAllMarks()) {
+ for (MarkConfiguration markConfiguration : courseConfiguration.getAllMarks()) {
if (markConfiguration.getAnnotationInfo().isStoreToInventory()) {
- MarkProperties markPropertiesOrNull = markConfiguration.getOptionalMarkProperties();
+ final MarkProperties markPropertiesOrNull = markConfiguration.getOptionalMarkProperties();
+ final MarkProperties markPropertiesInInventory;
final Positioning positioningOrNull = markConfiguration.getAnnotationInfo().getOptionalPositioning();
+ // create or update the non position-related aspects of the MarkProperties object in the "inventory":
if (markPropertiesOrNull == null) {
// If no mark properties exist yet, a new one is created
- markPropertiesOrNull = getSharedSailingData().createMarkProperties(markConfiguration.getEffectiveProperties(),
+ markPropertiesInInventory = getSharedSailingData().createMarkProperties(markConfiguration.getEffectiveProperties(),
/* tags */ Collections.emptySet(), optionalNonDefaultGroupOwnership);
} else {
// in the case of a MarkPropertiesBasedMarkConfiguration, the following call is expected to notice
// the identity between the mark properties object to update and the mark properties that constitute
// the effective properties and then skip the update.
- getSharedSailingData().updateMarkProperties(markPropertiesOrNull.getId(), markConfiguration.getEffectiveProperties(),
- positioningOrNull, Collections.emptySet());
+ markPropertiesInInventory = markPropertiesOrNull;
+ getSharedSailingData().updateMarkProperties(markPropertiesInInventory.getId(), markConfiguration.getEffectiveProperties(),
+ positioningOrNull, /* TODO tags */ Collections.emptySet());
}
if (positioningOrNull == null && markConfiguration instanceof RegattaMarkConfiguration) {
// Only for RegattaMarkConfiguration we can obtain the positioning directly from the Mark if available.
@@ -190,33 +222,33 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
final DeviceIdentifier deviceIdentifier = positioningOrNull.getDeviceIdentifier();
final Position fixedPosition = positioningOrNull.getPosition();
if (deviceIdentifier != null) {
- getSharedSailingData().setTrackingDeviceIdentifierForMarkProperties(markPropertiesOrNull, deviceIdentifier);
+ getSharedSailingData().setTrackingDeviceIdentifierForMarkProperties(markPropertiesInInventory, deviceIdentifier);
} else {
- getSharedSailingData().setFixedPositionForMarkProperties(markPropertiesOrNull, fixedPosition);
+ getSharedSailingData().setFixedPositionForMarkProperties(markPropertiesInInventory, fixedPosition);
}
}
- final MarkConfiguration effectiveMarkConfiguration;
+ final MarkConfiguration effectiveMarkConfiguration;
if (markConfiguration instanceof RegattaMarkConfiguration) {
- final RegattaMarkConfiguration regattaMarkConfiguration = (RegattaMarkConfiguration) markConfiguration;
- effectiveMarkConfiguration = new RegattaMarkConfigurationImpl(regattaMarkConfiguration.getMark(),
- markConfiguration.getOptionalPositioning(), regattaMarkConfiguration.getEffectivePositioning(),
- regattaMarkConfiguration.getOptionalMarkTemplate(), markPropertiesOrNull,
- false);
+ final RegattaMarkConfiguration regattaMarkConfiguration = (RegattaMarkConfiguration) markConfiguration;
+ effectiveMarkConfiguration = new RegattaMarkConfigurationImpl(regattaMarkConfiguration.getMark(),
+ CourseConfigurationBuilder.getPositioningIfAvailable(regatta, regattaMarkConfiguration.getMark(), positionResolver),
+ regattaMarkConfiguration.getOptionalMarkTemplate(), markPropertiesInInventory);
} else {
- effectiveMarkConfiguration = new MarkPropertiesBasedMarkConfigurationImpl(markPropertiesOrNull,
- markConfiguration.getOptionalMarkTemplate(), markConfiguration.getOptionalPositioning(),
- getPositioningIfAvailable(markPropertiesOrNull),
- false);
+ effectiveMarkConfiguration = new MarkPropertiesBasedMarkConfigurationImpl<>(markPropertiesInInventory,
+ markConfiguration.getOptionalMarkTemplate(), getPositioningIfAvailable(markPropertiesInInventory));
}
effectiveConfigurations.put(markConfiguration, effectiveMarkConfiguration);
} else {
+ // the request does not ask for this mark configuration to be stored to the MarkProperties "inventory" and hence
+ // we can use the markConfiguration as-is
effectiveConfigurations.put(markConfiguration, markConfiguration);
}
}
- final CourseConfigurationToCourseConfigurationMapper waypointConfigurationMapper = new CourseConfigurationToCourseConfigurationMapper(
+ final CourseConfigurationToCourseConfigurationMapper waypointConfigurationMapper =
+ new CourseConfigurationToCourseConfigurationMapper(
courseConfiguration.getWaypoints(), courseConfiguration.getAssociatedRoles(),
effectiveConfigurations);
- return new CourseConfigurationWithMarkRolesImpl(courseConfiguration.getOptionalCourseTemplate(),
+ return new CourseConfigurationWithMarkRolesImpl<>(courseConfiguration.getOptionalCourseTemplate(),
new HashSet<>(effectiveConfigurations.values()),
ensureMarkRoles(waypointConfigurationMapper.explicitAssociatedRoles),
waypointConfigurationMapper.effectiveWaypoints, courseConfiguration.getRepeatablePart(),
@@ -259,8 +291,8 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
final CourseConfiguration courseConfiguration, Iterable tags,
Optional optionalNonDefaultGroupOwnership) {
final CourseConfigurationWithMarkRoles courseConfigurationAfterInventory = handleSaveToInventory(courseConfiguration, optionalNonDefaultGroupOwnership);
- final Map, MarkTemplate> markTemplatesByMarkConfigurations = new HashMap<>();
- final Map, MarkConfiguration> marksConfigurationsMapping = new HashMap<>();
+ final Map, MarkTemplate> markTemplatesByMarkConfigurations = new HashMap<>();
+ final Map, MarkConfiguration> marksConfigurationsMapping = new HashMap<>();
for (MarkConfiguration markConfiguration : courseConfigurationAfterInventory.getAllMarks()) {
final MarkConfiguration effectiveConfiguration;
// TODO visitor pattern for MarkConfiguration?
@@ -273,8 +305,7 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
if (markTemplateOrNull != null && markTemplateOrNull.hasEqualAppeareanceWith(markConfiguration.getEffectiveProperties())) {
effectiveMarkTemplate = markTemplateOrNull;
} else {
- effectiveMarkTemplate = getSharedSailingData()
- .createMarkTemplate(markConfiguration.getEffectiveProperties());
+ effectiveMarkTemplate = getSharedSailingData().createMarkTemplate(markConfiguration.getEffectiveProperties());
}
if (markConfiguration instanceof RegattaMarkConfiguration) {
// The configuration is used as is. We can't enrich the Mark with the newly created MarkTemplate.
@@ -285,25 +316,25 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
// In this case the appearance of the created MarkTemplate is identical to the MarkProperties it is
// based on.
final MarkProperties markProperties = ((MarkPropertiesBasedMarkConfiguration) markConfiguration)
- .getMarkProperties();
+ .getOptionalMarkProperties();
effectiveConfiguration = new MarkPropertiesBasedMarkConfigurationImpl(markProperties,
effectiveMarkTemplate, getPositioningIfAvailable(markProperties));
} else if (markConfiguration instanceof FreestyleMarkConfiguration) {
- final MarkProperties markPropertiesOrNull = ((FreestyleMarkConfiguration) markConfiguration)
+ final MarkProperties markPropertiesOrNull = ((FreestyleMarkConfiguration) markConfiguration)
.getOptionalMarkProperties();
if (markPropertiesOrNull != null) {
if (markPropertiesOrNull.hasEqualAppeareanceWith(effectiveMarkTemplate)) {
- effectiveConfiguration = new MarkPropertiesBasedMarkConfigurationImpl(markPropertiesOrNull,
+ effectiveConfiguration = new MarkPropertiesBasedMarkConfigurationImpl<>(markPropertiesOrNull,
effectiveMarkTemplate, markConfiguration.getOptionalPositioning(), getPositioningIfAvailable(markPropertiesOrNull),
/* storeToInventory */ false);
} else {
- effectiveConfiguration = new FreestyleMarkConfigurationImpl(effectiveMarkTemplate,
+ effectiveConfiguration = new FreestyleMarkConfigurationImpl<>(effectiveMarkTemplate,
markPropertiesOrNull, effectiveMarkTemplate, markConfiguration.getOptionalPositioning(),
getPositioningIfAvailable(markPropertiesOrNull),
/* storeToInventory */ false);
}
} else {
- effectiveConfiguration = new MarkTemplateBasedMarkConfigurationImpl(effectiveMarkTemplate,
+ effectiveConfiguration = new MarkTemplateBasedMarkConfigurationImpl<>(effectiveMarkTemplate,
markConfiguration.getOptionalPositioning(),
/* storeToInventory */ false);
}
@@ -316,13 +347,14 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
marksConfigurationsMapping.put(markConfiguration, effectiveConfiguration);
}
final MarkPairTemplateFactory markPairTemplateFactory = new MarkPairTemplateFactory();
- final CourseConfigurationToCourseConfigurationMapper waypointConfigurationMapper = new CourseConfigurationToCourseConfigurationMapper(
+ final CourseConfigurationToCourseConfigurationMapper waypointConfigurationMapper = new CourseConfigurationToCourseConfigurationMapper<>(
courseConfigurationAfterInventory.getWaypoints(), courseConfigurationAfterInventory.getAssociatedRoles(),
marksConfigurationsMapping);
recordUsagesForMarkProperties(waypointConfigurationMapper.effectiveWaypoints, waypointConfigurationMapper.allAssociatedRoles);
- final CourseSequenceReplacementMapper waypointTemplateMapper = new CourseSequenceReplacementMapper(
- courseConfigurationAfterInventory.getWaypoints(), courseConfigurationAfterInventory.getAssociatedRoles(),
- markTemplatesByMarkConfigurations) {
+ final CourseSequenceReplacementMapper waypointTemplateMapper =
+ new CourseSequenceReplacementMapper(
+ courseConfigurationAfterInventory.getWaypoints(), courseConfigurationAfterInventory.getAssociatedRoles(),
+ markTemplatesByMarkConfigurations) {
@Override
protected ControlPointTemplate createMarkPair(MarkTemplate left, MarkTemplate right, String name,
String shortName) {
@@ -330,14 +362,16 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
}
@Override
- protected WaypointTemplate getOrCreateWaypoint(ControlPointTemplate controlPoint,
+ protected WaypointTemplate createWaypoint(ControlPointTemplate controlPoint,
PassingInstruction passingInstruction) {
return new WaypointTemplateImpl(controlPoint, passingInstruction);
}
};
- final CourseTemplate newCourseTemplate = getSharedSailingData().createCourseTemplate(courseConfigurationAfterInventory.getName(), new HashSet<>(markTemplatesByMarkConfigurations.values()),
- waypointTemplateMapper.effectiveWaypoints, ensureMarkRoles(waypointTemplateMapper.allAssociatedRoles), courseConfigurationAfterInventory.getRepeatablePart(),
- tags, courseConfigurationAfterInventory.getOptionalImageURL(),
+ final CourseTemplate newCourseTemplate = getSharedSailingData().createCourseTemplate(
+ courseConfigurationAfterInventory.getName(), new HashSet<>(markTemplatesByMarkConfigurations.values()),
+ waypointTemplateMapper.effectiveWaypoints, ensureMarkRoles(waypointTemplateMapper.allAssociatedRoles),
+ courseConfigurationAfterInventory.getRepeatablePart(), tags,
+ courseConfigurationAfterInventory.getOptionalImageURL(),
courseConfigurationAfterInventory.getNumberOfLaps());
return new CourseConfigurationImpl(newCourseTemplate,
new HashSet<>(marksConfigurationsMapping.values()),
@@ -346,16 +380,16 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
courseConfigurationAfterInventory.getName(), courseConfigurationAfterInventory.getOptionalImageURL());
}
- private void recordUsagesForMarkProperties(Iterable waypoints,
- Map associatedRoles) {
- for (MarkConfiguration markConfiguration : getAllMarkConfigurations(waypoints)) {
- final MarkProperties markProperties = getAssociatedMarkPropertiesIfAvailable(markConfiguration);
+ private void recordUsagesForMarkProperties(Iterable> effectiveWaypoints,
+ Map, IsMarkRole> allAssociatedRoles) {
+ for (MarkConfiguration markConfiguration : getAllMarkConfigurations(effectiveWaypoints)) {
+ final MarkProperties markProperties = markConfiguration.getOptionalMarkProperties();
if (markProperties != null) {
- final IsMarkRole role = getExplicitOrImplicitMarkRole(associatedRoles, markConfiguration);
+ final IsMarkRole role = getExplicitOrImplicitMarkRole(allAssociatedRoles, markConfiguration);
try {
getSharedSailingData().recordUsage(markProperties, ensureMarkRole(role));
} catch (Exception e) {
- log.log(Level.WARNING,
+ logger.log(Level.WARNING,
"Could not record usage for mark properties " + markProperties + " and role " + role,
e);
}
@@ -364,7 +398,7 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
try {
getSharedSailingData().recordUsage(markTemplateOrNull, markProperties);
} catch (Exception e) {
- log.log(Level.WARNING, "Could not record usage for mark properties " + markProperties
+ logger.log(Level.WARNING, "Could not record usage for mark properties " + markProperties
+ " and mark template " + markTemplateOrNull, e);
}
}
@@ -372,7 +406,7 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
}
}
- private IsMarkRole getExplicitOrImplicitMarkRole(Map associatedRoles, MarkConfiguration markConfiguration) {
+ private IsMarkRole getExplicitOrImplicitMarkRole(Map, ? extends IsMarkRole> associatedRoles, MarkConfiguration markConfiguration) {
IsMarkRole effectiveRole = associatedRoles.get(markConfiguration);
if (effectiveRole == null) {
effectiveRole = new MarkRoleNameImpl(markConfiguration.getEffectiveProperties().getName());
@@ -380,25 +414,14 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
return effectiveRole;
}
- private Iterable getAllMarkConfigurations(Iterable waypoints) {
- final Set result = new HashSet<>();
- for (WaypointWithMarkConfiguration waypoint : waypoints) {
+ private Iterable> getAllMarkConfigurations(Iterable> waypoints) {
+ final Set> result = new HashSet<>();
+ for (WaypointWithMarkConfiguration waypoint : waypoints) {
Util.addAll(waypoint.getControlPoint().getMarkConfigurations(), result);
}
return result;
}
- private MarkProperties getAssociatedMarkPropertiesIfAvailable(MarkConfiguration markConfiguration) {
- if (markConfiguration instanceof MarkPropertiesBasedMarkConfiguration) {
- return ((MarkPropertiesBasedMarkConfiguration) markConfiguration).getMarkProperties();
- } else if (markConfiguration instanceof RegattaMarkConfiguration) {
- return ((RegattaMarkConfiguration) markConfiguration).getOptionalMarkProperties();
- } else if (markConfiguration instanceof FreestyleMarkConfiguration) {
- return ((FreestyleMarkConfiguration) markConfiguration).getOptionalMarkProperties();
- }
- return null;
- }
-
private void savePositioningToMark(Regatta regatta, Mark mark, Positioning optionalExplicitPositioning,
MarkProperties optionalAssociatedMarkProperties, TimePoint timePointForDefinitionOfMarksAndDeviceMappings,
AbstractLogEventAuthor author) {
@@ -435,6 +458,7 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
});
}
if (position[0] != null ^ deviceIdentifier[0] != null) {
+ // FIXME this is a case for RaceLogTrackingAdapter.pingMark (however, RaceLogTrackingAdapter is not visible from here as it's part of a connector bundle)
final DeviceMappingWithRegattaLogEvent existingDeviceMapping = CourseConfigurationBuilder.findMostRecentOrOngoingMapping(regatta, mark);
boolean terminateOpenEndedDeviceMapping = false;
if (deviceIdentifier[0] != null) {
@@ -483,30 +507,23 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
@Override
public CourseBase createCourseFromConfigurationAndDefineMarksAsNeeded(Regatta regatta,
- final CourseConfiguration courseConfiguration, TimePoint timePointForDefinitionOfMarksAndDeviceMappings,
+ final CourseConfiguration courseConfiguration,
+ TimePoint timePointForDefinitionOfMarksAndDeviceMappings,
AbstractLogEventAuthor author, Optional optionalNonDefaultGroupOwnership) {
- final CourseConfigurationWithMarkRoles courseConfigurationAfterInventory = handleSaveToInventory(courseConfiguration, optionalNonDefaultGroupOwnership);
+ final CourseConfigurationWithMarkRoles courseConfigurationAfterInventory =
+ handleSaveToInventory(courseConfiguration, optionalNonDefaultGroupOwnership);
recordUsagesForMarkProperties(courseConfiguration.getWaypoints(), courseConfiguration.getAssociatedRoles());
- final Map marksByMarkConfigurations = new HashMap<>();
+ final Map, Mark> marksByMarkConfigurations = new HashMap<>();
final RegattaLog regattaLog = regatta.getRegattaLog();
- for (MarkConfiguration markConfiguration : courseConfigurationAfterInventory.getAllMarks()) {
+ for (MarkConfiguration markConfiguration : courseConfigurationAfterInventory.getAllMarks()) {
if (markConfiguration instanceof RegattaMarkConfiguration) {
- final Mark mark = ((RegattaMarkConfiguration) markConfiguration).getMark();
+ final Mark mark = ((RegattaMarkConfiguration) markConfiguration).getMark();
marksByMarkConfigurations.put(markConfiguration, mark);
- savePositioningToMark(regatta, mark, markConfiguration.getOptionalPositioning(), null,
+ savePositioningToMark(regatta, mark, markConfiguration.getOptionalPositioning(), /* optional MarkProperties */ null,
timePointForDefinitionOfMarksAndDeviceMappings, author);
} else {
final MarkTemplate optionalMarkTemplate = markConfiguration.getOptionalMarkTemplate();
- final MarkProperties optionalMarkProperties;
- if (markConfiguration instanceof MarkPropertiesBasedMarkConfiguration) {
- optionalMarkProperties = ((MarkPropertiesBasedMarkConfiguration) markConfiguration)
- .getMarkProperties();
- } else if (markConfiguration instanceof FreestyleMarkConfiguration) {
- optionalMarkProperties = ((FreestyleMarkConfiguration) markConfiguration)
- .getOptionalMarkProperties();
- } else {
- optionalMarkProperties = null;
- }
+ final MarkProperties optionalMarkProperties = markConfiguration.getOptionalMarkProperties();
final CommonMarkProperties effectiveProperties = markConfiguration.getEffectiveProperties();
final Mark markToCreate = domainFactory.getOrCreateMark(UUID.randomUUID(),
effectiveProperties.getName(), effectiveProperties.getShortName(),
@@ -521,10 +538,11 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
optionalMarkProperties, timePointForDefinitionOfMarksAndDeviceMappings, author);
}
}
+ // create the CourseBase result object:
final CourseDataImpl course = new CourseDataImpl(courseConfigurationAfterInventory.getName(),
courseConfigurationAfterInventory.getOptionalCourseTemplate() == null ? null
: courseConfigurationAfterInventory.getOptionalCourseTemplate().getId());
- final Iterable waypoints;
+ final Iterable> waypoints;
if (courseConfigurationAfterInventory.hasRepeatablePart()) {
if (courseConfigurationAfterInventory.getNumberOfLaps() == null) {
throw new IllegalStateException("A course with repeatable part requires a lap count");
@@ -533,15 +551,16 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
} else {
waypoints = courseConfigurationAfterInventory.getWaypoints();
}
- final CourseSequenceReplacementMapper courseSequenceMapper = new CourseSequenceReplacementMapper(
- waypoints, courseConfigurationAfterInventory.getAssociatedRoles(), marksByMarkConfigurations) {
+ final CourseSequenceReplacementMapper courseSequenceMapper =
+ new CourseSequenceReplacementMapper(
+ waypoints, courseConfigurationAfterInventory.getAssociatedRoles(), marksByMarkConfigurations) {
@Override
protected ControlPointWithTwoMarks createMarkPair(Mark left, Mark right, String name, String shortName) {
return new ControlPointWithTwoMarksImpl(UUID.randomUUID(), left, right, name, shortName);
}
@Override
- protected Waypoint getOrCreateWaypoint(ControlPoint controlPoint, PassingInstruction passingInstruction) {
+ protected Waypoint createWaypoint(ControlPoint controlPoint, PassingInstruction passingInstruction) {
return new WaypointImpl(controlPoint, passingInstruction);
}
};
@@ -552,16 +571,16 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
}
@Override
- public CourseConfiguration createCourseConfigurationFromTemplate(CourseTemplate courseTemplate,
+ public CourseConfiguration createCourseConfigurationFromTemplate(CourseTemplate courseTemplate,
Regatta optionalRegatta, Iterable tagsToFilterMarkProperties) {
- final Set allMarkConfigurations = new HashSet<>();
- final Map markTemplatesToMarkConfigurations = new HashMap<>();
+ final Set> allMarkConfigurations = new HashSet<>();
+ final Map> markTemplatesToMarkConfigurations = new HashMap<>();
if (optionalRegatta != null) {
// If we have a regatta context, we first try to get all existing marks and their association to
// MarkTemplates from the regatta
- final Map markConfigurationsByMarkTemplate = new HashMap<>();
- final Map markConfigurationsByMark = new HashMap<>();
- final Map lastUsages = new HashMap<>();
+ final Map> markConfigurationsByMarkTemplate = new HashMap<>();
+ final Map> markConfigurationsByMark = new HashMap<>();
+ final Map, TimePoint> lastUsages = new HashMap<>();
for (RaceColumn raceColumn : optionalRegatta.getRaceColumns()) {
for (Mark mark : raceColumn.getAvailableMarks()) {
markConfigurationsByMark
@@ -569,7 +588,7 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
m -> createMarkConfigurationForRegattaMark(courseTemplate, optionalRegatta, m));
}
}
- final LastUsageBasedAssociater usagesForRole = new LastUsageBasedAssociater<>(
+ final LastUsageBasedAssociater, IsMarkRole> usagesForRole = new LastUsageBasedAssociater<>(
new HashSet(courseTemplate.getAssociatedRoles().values()));
for (RaceColumn raceColumn : optionalRegatta.getRaceColumns()) {
for (Fleet fleet : raceColumn.getFleets()) {
@@ -602,7 +621,7 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
final TimePoint effectiveUsageTP = usage;
for (Waypoint waypoint : courseOrNull.getWaypoints()) {
for (Mark mark : waypoint.getMarks()) {
- final RegattaMarkConfiguration regattaMarkConfiguration = markConfigurationsByMark
+ final RegattaMarkConfiguration regattaMarkConfiguration = markConfigurationsByMark
.computeIfAbsent(mark,
m -> createMarkConfigurationForRegattaMark(courseTemplate, optionalRegatta, m));
lastUsages.compute(regattaMarkConfiguration,
@@ -626,7 +645,7 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
MarkTemplate mt = iterator.next();
MarkRole roleOrNull = courseTemplate.getAssociatedRoles().get(mt);
if (roleOrNull != null) {
- RegattaMarkConfiguration bestMatchForRole = usagesForRole.getBestMatchForT2(roleOrNull);
+ RegattaMarkConfiguration bestMatchForRole = usagesForRole.getBestMatchForT2(roleOrNull);
if (bestMatchForRole != null) {
iterator.remove();
markConfigurationsByMarkTemplate.put(mt, bestMatchForRole);
@@ -636,7 +655,7 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
}
}
// Marks that couldn't be matched by a role could be directly matched by an originating MarkTemplate and last usage
- for (RegattaMarkConfiguration regattaMarkConfiguration : usagesForRole.usagesByT1.keySet()) {
+ for (RegattaMarkConfiguration regattaMarkConfiguration : usagesForRole.usagesByT1.keySet()) {
final MarkTemplate associatedMarkTemplateOrNull = regattaMarkConfiguration.getOptionalMarkTemplate();
if (associatedMarkTemplateOrNull != null) {
markConfigurationsByMarkTemplate.compute(associatedMarkTemplateOrNull, (mt, rmc) -> {
@@ -662,26 +681,26 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
for (MarkTemplate markTemplate : courseTemplate.getMarkTemplates()) {
// For any MarkTemplate that wasn't resolved from the regatta, an explicit entry needs to get created
markTemplatesToMarkConfigurations.computeIfAbsent(markTemplate, mt -> {
- final MarkConfiguration markConfiguration = new MarkTemplateBasedMarkConfigurationImpl(markTemplate,
- null, /* storeToInventory */ false);
+ final MarkConfiguration markConfiguration = new MarkTemplateBasedMarkConfigurationImpl<>(markTemplate,
+ /* no positioning information for a MarkTemplate-based mark configuration */ null);
allMarkConfigurations.add(markConfiguration);
return markConfiguration;
});
}
replaceTemplateBasedConfigurationCandidatesBySuggestedProperties(markTemplatesToMarkConfigurations, allMarkConfigurations, tagsToFilterMarkProperties,
courseTemplate.getAssociatedRoles());
- final Map resultingRoleMapping = createRoleMappingWithMarkTemplateMapping(
+ final Map, IsMarkRole> resultingRoleMapping = createRoleMappingWithMarkTemplateMapping(
courseTemplate, markTemplatesToMarkConfigurations);
- final List resultingWaypoints = createWaypointConfigurationsWithMarkTemplateMapping(
+ final List> resultingWaypoints = createWaypointConfigurationsWithMarkTemplateMapping(
courseTemplate, markTemplatesToMarkConfigurations);
- return new CourseConfigurationImpl(courseTemplate, allMarkConfigurations, resultingRoleMapping,
+ return new CourseConfigurationImpl(courseTemplate, allMarkConfigurations, resultingRoleMapping,
resultingWaypoints, courseTemplate.getRepeatablePart(), courseTemplate.getDefaultNumberOfLaps(),
courseTemplate.getName(), courseTemplate.getOptionalImageURL());
}
- private Map createRoleMappingWithMarkTemplateMapping(CourseTemplate courseTemplate,
- final Map markTemplatesToMarkConfigurations) {
- final Map resultingRoleMapping = new HashMap<>();
+ private Map, IsMarkRole> createRoleMappingWithMarkTemplateMapping(CourseTemplate courseTemplate,
+ final Map> markTemplatesToMarkConfigurations) {
+ final Map, IsMarkRole> resultingRoleMapping = new HashMap<>();
for (Entry markTemplateWithRole : courseTemplate.getAssociatedRoles().entrySet()) {
resultingRoleMapping.put(markTemplatesToMarkConfigurations.get(markTemplateWithRole.getKey()),
markTemplateWithRole.getValue());
@@ -689,38 +708,38 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
return resultingRoleMapping;
}
- private List createWaypointConfigurationsWithMarkTemplateMapping(
+ private List> createWaypointConfigurationsWithMarkTemplateMapping(
CourseTemplate courseTemplate,
- final Map markTemplatesToMarkConfigurations) {
- final List resultingWaypoints = new ArrayList<>();
+ final Map> markTemplatesToMarkConfigurations) {
+ final List> resultingWaypoints = new ArrayList<>();
for (WaypointTemplate waypointTemplate : courseTemplate.getWaypointTemplates()) {
final ControlPointTemplate controlPointTemplate = waypointTemplate.getControlPointTemplate();
- final ControlPointWithMarkConfiguration resultingControlPoint;
+ final ControlPointWithMarkConfiguration resultingControlPoint;
if (controlPointTemplate instanceof MarkTemplate) {
MarkTemplate markTemplate = (MarkTemplate) controlPointTemplate;
resultingControlPoint = markTemplatesToMarkConfigurations.get(markTemplate);
} else {
final MarkPairTemplate markPairTemplate = (MarkPairTemplate) controlPointTemplate;
- final MarkConfiguration left = markTemplatesToMarkConfigurations.get(markPairTemplate.getLeft());
- final MarkConfiguration right = markTemplatesToMarkConfigurations.get(markPairTemplate.getRight());
- resultingControlPoint = new MarkPairWithConfigurationImpl(markPairTemplate.getName(), left, right,
+ final MarkConfiguration left = markTemplatesToMarkConfigurations.get(markPairTemplate.getLeft());
+ final MarkConfiguration right = markTemplatesToMarkConfigurations.get(markPairTemplate.getRight());
+ resultingControlPoint = new MarkPairWithConfigurationImpl<>(markPairTemplate.getName(), left, right,
markPairTemplate.getShortName());
}
- resultingWaypoints.add(new WaypointWithMarkConfigurationImpl(resultingControlPoint,
+ resultingWaypoints.add(new WaypointWithMarkConfigurationImpl<>(resultingControlPoint,
waypointTemplate.getPassingInstruction()));
}
return resultingWaypoints;
}
@Override
- public CourseConfiguration createCourseConfigurationFromRegatta(CourseBase course, Regatta regatta,
+ public CourseConfiguration createCourseConfigurationFromRegatta(CourseBase course, Regatta regatta,
Iterable tagsToFilterMarkProperties) {
assert regatta != null;
- final Set allMarkConfigurations = new HashSet<>();
+ final Set> allMarkConfigurations = new HashSet<>();
final CourseTemplate courseTemplateOrNull = course == null ? null : resolveCourseTemplateSafe(course);
- final Map markConfigurationsByMark = createMarkConfigurationsForRegatta(regatta, courseTemplateOrNull);
+ final Map> markConfigurationsByMark = createMarkConfigurationsForRegatta(regatta, courseTemplateOrNull);
allMarkConfigurations.addAll(markConfigurationsByMark.values());
- final Map resultingRoleMapping = new HashMap<>();
+ final Map, IsMarkRole> resultingRoleMapping = new HashMap<>();
if (course != null) {
for (Entry entry : course.getAssociatedRoles().entrySet()) {
resultingRoleMapping.put(markConfigurationsByMark.get(entry.getKey()),
@@ -729,7 +748,7 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
}
String name = null;
URL optionalImageURL = null;
- final List resultingWaypoints = new ArrayList<>();
+ final List> resultingWaypoints = new ArrayList<>();
RepeatablePart optionalRepeatablePart = null;
Integer numberOfLaps = null;
boolean handledByTemplate = false;
@@ -738,12 +757,12 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
if (mapper.validCourseTemplateUsage) {
name = courseTemplateOrNull.getName();
optionalImageURL = courseTemplateOrNull.getOptionalImageURL();
- final Map markTemplatesToMarkConfigurations = new HashMap<>();
+ final Map> markTemplatesToMarkConfigurations = new HashMap<>();
markTemplatesToMarkConfigurations.putAll(mapper.markTemplatesToMarkConfigurations);
if (!mapper.markTemplatesNotIncluded.isEmpty()) {
for (MarkTemplate markTemplate : mapper.markTemplatesNotIncluded) {
- final MarkConfiguration markConfiguration = new MarkTemplateBasedMarkConfigurationImpl(
- markTemplate, null, /* storeToInventory */ false);
+ final MarkConfiguration markConfiguration = new MarkTemplateBasedMarkConfigurationImpl(
+ markTemplate, /* response annotation: nothing known about positioning */ null);
markTemplatesToMarkConfigurations.put(markTemplate, markConfiguration);
resultingRoleMapping.put(markConfiguration,
courseTemplateOrNull.getOptionalAssociatedRole(markTemplate));
@@ -768,30 +787,30 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
}
for (Waypoint waypoint : course.getWaypoints()) {
final ControlPoint controlPoint = waypoint.getControlPoint();
- final ControlPointWithMarkConfiguration resultingControlPoint;
+ final ControlPointWithMarkConfiguration resultingControlPoint;
if (controlPoint instanceof Mark) {
final Mark mark = (Mark) controlPoint;
resultingControlPoint = markConfigurationsByMark.get(mark);
} else {
final ControlPointWithTwoMarks markPairTemplate = (ControlPointWithTwoMarks) controlPoint;
- final MarkConfiguration left = markConfigurationsByMark
+ final MarkConfiguration left = markConfigurationsByMark
.get(markPairTemplate.getLeft());
- final MarkConfiguration right = markConfigurationsByMark
+ final MarkConfiguration right = markConfigurationsByMark
.get(markPairTemplate.getRight());
- resultingControlPoint = new MarkPairWithConfigurationImpl(markPairTemplate.getName(), left, right,
+ resultingControlPoint = new MarkPairWithConfigurationImpl<>(markPairTemplate.getName(), left, right,
markPairTemplate.getShortName());
}
- resultingWaypoints.add(new WaypointWithMarkConfigurationImpl(resultingControlPoint,
+ resultingWaypoints.add(new WaypointWithMarkConfigurationImpl<>(resultingControlPoint,
waypoint.getPassingInstructions()));
}
}
}
- return new CourseConfigurationImpl(courseTemplateOrNull, allMarkConfigurations, resultingRoleMapping,
+ return new CourseConfigurationImpl(courseTemplateOrNull, allMarkConfigurations, resultingRoleMapping,
resultingWaypoints, optionalRepeatablePart, numberOfLaps, name, optionalImageURL);
}
- private Map createMarkConfigurationsForRegatta(Regatta regatta, CourseTemplate courseTemplate) {
- final Map result = new HashMap<>();
+ private Map> createMarkConfigurationsForRegatta(Regatta regatta, CourseTemplate courseTemplate) {
+ final Map> result = new HashMap<>();
for (RaceColumn raceColumn : regatta.getRaceColumns()) {
for (Mark mark : raceColumn.getAvailableMarks()) {
result
@@ -805,10 +824,11 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
private class CourseToCourseTemplateMapper {
boolean validCourseTemplateUsage;
Integer numberOfLaps;
- final Map markTemplatesToMarkConfigurations = new HashMap<>();
+ final Map> markTemplatesToMarkConfigurations = new HashMap<>();
final Set markTemplatesNotIncluded = new HashSet<>();
- public CourseToCourseTemplateMapper(CourseBase course, CourseTemplate courseTemplate, Map markConfigurationsByMark) {
+ public CourseToCourseTemplateMapper(CourseBase course, CourseTemplate courseTemplate,
+ Map> markConfigurationsByMark) {
validCourseTemplateUsage = false;
RepeatablePart optionalRepeatablePart = null;
numberOfLaps = null;
@@ -862,7 +882,7 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
validCourseTemplateUsage = false;
break;
}
- final RegattaMarkConfiguration regattaMarkConfiguration = markConfigurationsByMark
+ final RegattaMarkConfiguration regattaMarkConfiguration = markConfigurationsByMark
.get(mark);
markTemplatesToMarkConfigurations.putIfAbsent(markTemplate, regattaMarkConfiguration);
}
@@ -874,31 +894,29 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
}
}
- private void replaceTemplateBasedConfigurationCandidatesBySuggestedProperties(Map markTemplatesToMarkConfigurationsToReplace,
- Set markConfigurationsToEdit, Iterable tagsToFilterMarkProperties,
+ private void replaceTemplateBasedConfigurationCandidatesBySuggestedProperties(
+ Map> markTemplatesToMarkConfigurationsToReplace,
+ Set> markConfigurationsToEdit, Iterable tagsToFilterMarkProperties,
Map associatedRoles) {
// find candidates for replacement of mark configuration
- final Map replacementCandidates = markTemplatesToMarkConfigurationsToReplace.entrySet()
- .stream().filter(e -> e.getValue() instanceof MarkTemplateBasedMarkConfiguration)
- .collect(Collectors.toMap(s -> s.getKey(), s -> (MarkTemplateBasedMarkConfiguration)s.getValue()));
-
+ final Map> replacementCandidates = markTemplatesToMarkConfigurationsToReplace
+ .entrySet().stream().filter(e -> e.getValue() instanceof MarkTemplateBasedMarkConfiguration)
+ .collect(Collectors.toMap(s -> s.getKey(), s -> (MarkTemplateBasedMarkConfiguration) s.getValue()));
final Set markPropertiesCandidates = new HashSet<>();
Util.addAll(getSharedSailingData().getAllMarkProperties(tagsToFilterMarkProperties), markPropertiesCandidates);
// Already included mark properties may not get associated again
markPropertiesCandidates.removeAll(markConfigurationsToEdit.stream()
.map(this::getAssociatedMarkPropertiesIfAvailable).filter(v -> v != null).collect(Collectors.toSet()));
-
final LastUsageBasedAssociater roleBasedAssociater = new LastUsageBasedAssociater<>(
replacementCandidates.keySet().stream().map(associatedRoles::get).filter(v -> v != null)
.collect(Collectors.toSet()));
-
for (MarkProperties mp : markPropertiesCandidates) {
roleBasedAssociater.addUsages(mp, mp.getLastUsedRole());
}
final Map suggestedMappings = new HashMap<>();
- for (Iterator> iterator = replacementCandidates.entrySet().iterator(); iterator
+ for (Iterator>> iterator = replacementCandidates.entrySet().iterator(); iterator
.hasNext();) {
- Entry entry = iterator.next();
+ Entry> entry = iterator.next();
final MarkRole roleName = associatedRoles.get(entry.getKey());
if (roleName != null) {
final MarkProperties bestMatchOrNull = roleBasedAssociater.getBestMatchForT2(roleName);
@@ -915,21 +933,20 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
for (MarkProperties mp : markPropertiesCandidates) {
roleBasedAssociater.addUsages(mp, mp.getLastUsedRole());
}
- for (Entry entry : replacementCandidates.entrySet()) {
+ for (Entry> entry : replacementCandidates.entrySet()) {
final MarkProperties bestMatchOrNull = templateBasedAssociater.getBestMatchForT2(entry.getKey());
if (bestMatchOrNull != null) {
suggestedMappings.put(entry.getKey(), bestMatchOrNull);
}
}
// replace candidates if possible
- for (Map.Entry entr : replacementCandidates.entrySet()) {
+ for (Map.Entry> entr : replacementCandidates.entrySet()) {
final MarkTemplate keyTemplate = entr.getKey();
if (suggestedMappings.containsKey(keyTemplate)) {
final MarkProperties suggestedPropertiesMapping = suggestedMappings.get(keyTemplate);
- final MarkPropertiesBasedMarkConfigurationImpl newMarkPropertiesBasedConfiguration = new MarkPropertiesBasedMarkConfigurationImpl(
- suggestedPropertiesMapping, keyTemplate, /* optionalPositioning */ null, getPositioningIfAvailable(suggestedPropertiesMapping),
- /* storeToInventory */ false);
-
+ final MarkPropertiesBasedMarkConfigurationImpl newMarkPropertiesBasedConfiguration =
+ new MarkPropertiesBasedMarkConfigurationImpl<>(suggestedPropertiesMapping, keyTemplate,
+ getPositioningIfAvailable(suggestedPropertiesMapping));
markTemplatesToMarkConfigurationsToReplace.put(keyTemplate, newMarkPropertiesBasedConfiguration);
markConfigurationsToEdit.remove(entr.getValue());
markConfigurationsToEdit.add(newMarkPropertiesBasedConfiguration);
@@ -986,47 +1003,47 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
return regattaMarkConfiguration;
}
- private abstract class CourseSequenceMapper {
+ private abstract class CourseSequenceMapper {
final Map explicitAssociatedRoles = new HashMap<>();
final Map allAssociatedRoles = new HashMap<>();
final List effectiveWaypoints = new ArrayList<>();
- private final Iterable waypoints;
- private final Map existingRoleMapping;
+ private final Iterable> waypoints;
+ private final Map, ? extends IsMarkRole> existingRoleMapping;
- public CourseSequenceMapper(Iterable waypoints,
- Map existingRoleMapping) {
+ public CourseSequenceMapper(Iterable> waypoints,
+ Map, ? extends IsMarkRole> existingRoleMapping) {
this.waypoints = waypoints;
this.existingRoleMapping = existingRoleMapping;
}
public void calculateEffectiveWaypoints() {
// all preexisting explicit roles are added to the result
- for (Entry entry : existingRoleMapping.entrySet()) {
+ for (Entry, ? extends IsMarkRole> entry : existingRoleMapping.entrySet()) {
explicitAssociatedRoles.put(mapMarkConfiguration(entry.getKey()), entry.getValue());
}
allAssociatedRoles.putAll(explicitAssociatedRoles);
// Cache to allow reusing ControlPointWithTwoMarks objects that are based on the same MarkPairWithConfiguration
- final Map markPairCache = new HashMap<>();
- for (WaypointWithMarkConfiguration waypointWithMarkConfiguration : waypoints) {
- final ControlPointWithMarkConfiguration controlPointWithMarkConfiguration = waypointWithMarkConfiguration.getControlPoint();
+ final Map, CP> markPairCache = new HashMap<>();
+ for (WaypointWithMarkConfiguration waypointWithMarkConfiguration : waypoints) {
+ final ControlPointWithMarkConfiguration
controlPointWithMarkConfiguration = waypointWithMarkConfiguration.getControlPoint();
if (controlPointWithMarkConfiguration instanceof MarkConfiguration) {
- final MarkConfiguration markConfiguration = (MarkConfiguration) controlPointWithMarkConfiguration;
+ final MarkConfiguration
markConfiguration = (MarkConfiguration
) controlPointWithMarkConfiguration;
effectiveWaypoints.add(
- getOrCreateWaypoint(mapMarkConfiguration(markConfiguration), waypointWithMarkConfiguration.getPassingInstruction()));
+ createWaypoint(mapMarkConfiguration(markConfiguration), waypointWithMarkConfiguration.getPassingInstruction()));
} else {
- final C controlPoint = markPairCache
- .computeIfAbsent((MarkPairWithConfiguration) controlPointWithMarkConfiguration, mpwc -> {
+ final CP controlPoint = markPairCache
+ .computeIfAbsent((MarkPairWithConfiguration
) controlPointWithMarkConfiguration, mpwc -> {
final M left = mapMarkConfiguration(mpwc.getLeft());
final M right = mapMarkConfiguration(mpwc.getRight());
return createMarkPair(left, right, mpwc.getName(), mpwc.getShortName());
});
effectiveWaypoints.add(
- getOrCreateWaypoint(controlPoint, waypointWithMarkConfiguration.getPassingInstruction()));
+ createWaypoint(controlPoint, waypointWithMarkConfiguration.getPassingInstruction()));
}
}
}
- private M mapMarkConfiguration(MarkConfiguration markConfiguration) {
+ private M mapMarkConfiguration(MarkConfiguration
markConfiguration) {
final M mark = getOrCreateMarkReplacement(markConfiguration);
if (mark == null) {
throw new IllegalStateException("Non declared mark found in waypoint sequence");
@@ -1036,45 +1053,45 @@ public class CourseAndMarkConfigurationFactoryImpl implements CourseAndMarkConfi
return mark;
}
- protected abstract M getOrCreateMarkReplacement(MarkConfiguration markConfiguration);
+ protected abstract M getOrCreateMarkReplacement(MarkConfiguration
markConfiguration);
- protected abstract C createMarkPair(M left, M right, String name, String shortName);
+ protected abstract CP createMarkPair(M left, M right, String name, String shortName);
- protected abstract W getOrCreateWaypoint(C controlPoint, PassingInstruction passingInstruction);
+ protected abstract W createWaypoint(CP controlPoint, PassingInstruction passingInstruction);
}
- private abstract class CourseSequenceReplacementMapper extends CourseSequenceMapper {
- private final Map, M> existingMapping;
+ private abstract class CourseSequenceReplacementMapper extends CourseSequenceMapper {
+ private final Map, M> existingMapping;
- public CourseSequenceReplacementMapper(Iterable waypoints,
- Map existingRoleMapping, Map, M> existingMapping) {
+ public CourseSequenceReplacementMapper(Iterable> waypoints,
+ Map, ? extends IsMarkRole> existingRoleMapping, Map, M> existingMapping) {
super(waypoints, existingRoleMapping);
this.existingMapping = existingMapping;
calculateEffectiveWaypoints();
}
@Override
- protected M getOrCreateMarkReplacement(MarkConfiguration markConfiguration) {
+ protected M getOrCreateMarkReplacement(MarkConfiguration markConfiguration) {
return existingMapping.get(markConfiguration);
}
}
- private class CourseConfigurationToCourseConfigurationMapper extends
- CourseSequenceReplacementMapper {
- public CourseConfigurationToCourseConfigurationMapper(Iterable waypoints,
- Map existingRoleMapping,
- Map existingMapping) {
+ private class CourseConfigurationToCourseConfigurationMapper extends
+ CourseSequenceReplacementMapper, MarkConfiguration, WaypointWithMarkConfiguration
, P> {
+ public CourseConfigurationToCourseConfigurationMapper(Iterable> waypoints,
+ Map, ? extends IsMarkRole> existingRoleMapping,
+ Map, MarkConfiguration> existingMapping) {
super(waypoints, existingRoleMapping, existingMapping);
}
@Override
- protected MarkPairWithConfiguration createMarkPair(MarkConfiguration left, MarkConfiguration right, String name, String shortName) {
- return new MarkPairWithConfigurationImpl(name, left, right, shortName);
+ protected MarkPairWithConfiguration
createMarkPair(MarkConfiguration
left, MarkConfiguration
right, String name, String shortName) {
+ return new MarkPairWithConfigurationImpl<>(name, left, right, shortName);
}
@Override
- protected WaypointWithMarkConfiguration getOrCreateWaypoint(ControlPointWithMarkConfiguration controlPoint, PassingInstruction passingInstruction) {
- return new WaypointWithMarkConfigurationImpl(controlPoint, passingInstruction);
+ protected WaypointWithMarkConfiguration
createWaypoint(ControlPointWithMarkConfiguration
controlPoint, PassingInstruction passingInstruction) {
+ return new WaypointWithMarkConfigurationImpl<>(controlPoint, passingInstruction);
}
};
diff --git a/java/com.sap.sailing.shared.persistence/src/com/sap/sailing/shared/persistence/impl/MongoObjectFactoryImpl.java b/java/com.sap.sailing.shared.persistence/src/com/sap/sailing/shared/persistence/impl/MongoObjectFactoryImpl.java
index b473ecf8939..1c9b3e1b2a8 100644
--- a/java/com.sap.sailing.shared.persistence/src/com/sap/sailing/shared/persistence/impl/MongoObjectFactoryImpl.java
+++ b/java/com.sap.sailing.shared.persistence/src/com/sap/sailing/shared/persistence/impl/MongoObjectFactoryImpl.java
@@ -128,21 +128,32 @@ public class MongoObjectFactoryImpl implements MongoObjectFactory {
public static Document storeDeviceId(
TypeBasedServiceFinder deviceIdentifierServiceFinder, DeviceIdentifier device)
throws TransformationException, NoCorrespondingServiceRegisteredException {
- String type = device.getIdentifierType();
- DeviceIdentifierMongoHandler handler = deviceIdentifierServiceFinder.findService(type);
- com.sap.sse.common.Util.Pair pair = handler.serialize(device);
- type = pair.getA();
- Object deviceTypeSpecificId = pair.getB();
- return new Document()
- .append(FieldNames.DEVICE_TYPE.name(), type)
- .append(FieldNames.DEVICE_TYPE_SPECIFIC_ID.name(), deviceTypeSpecificId)
- .append(FieldNames.DEVICE_STRING_REPRESENTATION.name(), device.getStringRepresentation());
+ final Document result;
+ if (device == null) {
+ result = null;
+ } else {
+ String type = device.getIdentifierType();
+ DeviceIdentifierMongoHandler handler = deviceIdentifierServiceFinder.findService(type);
+ com.sap.sse.common.Util.Pair pair = handler.serialize(device);
+ type = pair.getA();
+ Object deviceTypeSpecificId = pair.getB();
+ result = new Document()
+ .append(FieldNames.DEVICE_TYPE.name(), type)
+ .append(FieldNames.DEVICE_TYPE_SPECIFIC_ID.name(), deviceTypeSpecificId)
+ .append(FieldNames.DEVICE_STRING_REPRESENTATION.name(), device.getStringRepresentation());
+ }
+ return result;
}
private Document storePosition(Position position) {
- Document result = new Document();
- result.put(FieldNames.LAT_DEG.name(), position.getLatDeg());
- result.put(FieldNames.LNG_DEG.name(), position.getLngDeg());
+ final Document result;
+ if (position == null) {
+ result = null;
+ } else {
+ result = new Document();
+ result.put(FieldNames.LAT_DEG.name(), position.getLatDeg());
+ result.put(FieldNames.LNG_DEG.name(), position.getLngDeg());
+ }
return result;
}
@@ -150,7 +161,6 @@ public class MongoObjectFactoryImpl implements MongoObjectFactory {
if (markProperties.getColor() != null) {
result.put(FieldNames.COMMON_MARK_PROPERTIES_COLOR.name(), markProperties.getColor().getAsHtml());
}
-
result.put(FieldNames.COMMON_MARK_PROPERTIES_NAME.name(), markProperties.getName());
result.put(FieldNames.COMMON_MARK_PROPERTIES_PATTERN.name(), markProperties.getPattern());
result.put(FieldNames.COMMON_MARK_PROPERTIES_SHAPE.name(), markProperties.getShape());
diff --git a/java/com.sap.sailing.shared.server/src/com/sap/sailing/shared/server/impl/SharedSailingDataImpl.java b/java/com.sap.sailing.shared.server/src/com/sap/sailing/shared/server/impl/SharedSailingDataImpl.java
index 3eca92093de..7ac068ade1c 100644
--- a/java/com.sap.sailing.shared.server/src/com/sap/sailing/shared/server/impl/SharedSailingDataImpl.java
+++ b/java/com.sap.sailing.shared.server/src/com/sap/sailing/shared/server/impl/SharedSailingDataImpl.java
@@ -231,7 +231,7 @@ public class SharedSailingDataImpl implements ReplicatingSharedSailingData, Clea
public MarkProperties updateMarkProperties(UUID uuid, CommonMarkProperties properties,
Positioning positioningInformation, Iterable tags) {
final MarkProperties markProperties = updateMarkProperties(uuid, properties, tags);
- if (markProperties != properties) { // no update required if same object
+ if (positioningInformation != null && markProperties != properties) { // no update required if same object
apply(s -> internalSetPositioningInformationForMarkProperties(uuid, positioningInformation));
}
return getMarkPropertiesById(uuid);
diff --git a/wiki/coursecreation/course-templates-and-configuration.md b/wiki/coursecreation/course-templates-and-configuration.md
index 9df55bb09c3..a85707d3f24 100644
--- a/wiki/coursecreation/course-templates-and-configuration.md
+++ b/wiki/coursecreation/course-templates-and-configuration.md
@@ -214,6 +214,7 @@ Said that, it is necessary to provide a distinct and complete (bijective) mappin
New configurations may be created (e.g. by adding a new mark to the sequence or course configuration) as follows:
* Freestyle configuration: Adding a new mark
* Mark properties based configuration: By selecting a mark from the mark properties inventory
+* TODO Mark template based configuration?
In addition, for marks used in the course sequence, a new freestyle mark configuration may be created replacing the original configuration in the role. This causes the previous configuration to remain unused but not to be deleted automatically.