work commit

java/com.sap.sailing.domain.persistence/src/com/sap/sailing/domain/persistence/media/DBMediaTrack.java

@@ -4,17 +4,21 @@ import java.util.Date;
 
 public class DBMediaTrack {
     
+    public final String dbId;
     public final String title;
     public final String url;
     public final Date startTime;
+    public final int durationInMillis;
     public final String mimeType;
     public final String mimeSubType;
 
-    public DBMediaTrack(String title, String url, Date startTime, String mimeType, String mimeSubType) {
+    public DBMediaTrack(String dbId, String title, String url, Date startTime, int duration, String mimeType, String mimeSubType) {
         super();
+        this.dbId = dbId;
         this.title = title;
         this.url = url;
         this.startTime = startTime;
+        this.durationInMillis = duration;
         this.mimeType = mimeType;
         this.mimeSubType = mimeSubType;
     }

java/com.sap.sailing.domain.persistence/src/com/sap/sailing/domain/persistence/media/MediaDB.java

@@ -1,10 +1,9 @@
 package com.sap.sailing.domain.persistence.media;
 
+import java.util.Collection;
 import java.util.Date;
 import java.util.List;
 
-import com.mongodb.DBObject;
-
 /**
  * Offers CRUD methods for mongo representation of media track objects.
  * 
@@ -13,12 +12,18 @@ import com.mongodb.DBObject;
  */
 public interface MediaDB {
 
-    void insertMediaTrack(String videoTitle, String url, Date startTime, String mediaType, String mediaSubType);
+    String insertMediaTrack(String title, String url, Date startTime, int durationInMillis, String mediaType, String mediaSubType);
 
-    DBMediaTrack loadMediaTrack(String videoTitle);
+    DBMediaTrack loadMediaTrack(String dbId);
 
     List<DBMediaTrack> loadAllMediaTracks();
 
     void deleteMediaTrack(String title);
 
+    void updateStartTime(String title, Date startTime);
+
+    void updateDuration(String dbId, int durationInMillis);
+
+    Collection<DBMediaTrack> queryOverlappingMediaTracks(Date rangeStart, Date rangeEnd);
+
 }

java/com.sap.sailing.domain.persistence/src/com/sap/sailing/domain/persistence/media/impl/DbNames.java

@@ -3,7 +3,7 @@ package com.sap.sailing.domain.persistence.media.impl;
 public class DbNames {
 
     public enum Fields {
-        MEDIA_TITLE, MEDIA_URL, STARTTIME, MIME_TYPE, MIME_SUBTYPE;
+        _id, MEDIA_TITLE, MEDIA_URL, STARTTIME, DURATION_IN_MILLIS, MIME_TYPE, MIME_SUBTYPE;
     }
 
     public enum Collections {

java/com.sap.sailing.domain.persistence/src/com/sap/sailing/domain/persistence/media/impl/MediaDBImpl.java

@@ -1,23 +1,30 @@
 package com.sap.sailing.domain.persistence.media.impl;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Date;
 import java.util.List;
-import java.util.logging.Logger;
+
+import org.bson.types.ObjectId;
 
 import com.mongodb.BasicDBObject;
 import com.mongodb.DB;
 import com.mongodb.DBCollection;
 import com.mongodb.DBCursor;
 import com.mongodb.DBObject;
-import com.mongodb.WriteResult;
-import com.sap.sailing.domain.persistence.impl.FieldNames;
+import com.mongodb.QueryBuilder;
 import com.sap.sailing.domain.persistence.media.DBMediaTrack;
 import com.sap.sailing.domain.persistence.media.MediaDB;
 
+/**
+ * MongoDB Java API examples: http://blog.rasc.ch/?p=1096
+ * 
+ * @author D047974
+ * 
+ */
 public class MediaDBImpl implements MediaDB {
 
-    private static Logger logger = Logger.getLogger(MediaDBImpl.class.getName());
+    // private static Logger logger = Logger.getLogger(MediaDBImpl.class.getName());
     private final DB database;
 
     public MediaDBImpl(DB database) {
@@ -26,15 +33,17 @@ public class MediaDBImpl implements MediaDB {
     }
 
     @Override
-    public void insertMediaTrack(String videoTitle, String url, Date startTime, String mediaType, String mediaSubType) {
+    public String insertMediaTrack(String videoTitle, String url, Date startTime, int durationInMillis, String mediaType, String mediaSubType) {
         BasicDBObject dbVideo = new BasicDBObject();
         dbVideo.put(DbNames.Fields.MEDIA_TITLE.name(), videoTitle);
         dbVideo.put(DbNames.Fields.MEDIA_URL.name(), url);
         dbVideo.put(DbNames.Fields.STARTTIME.name(), startTime);
+        dbVideo.put(DbNames.Fields.DURATION_IN_MILLIS.name(), durationInMillis);
         dbVideo.put(DbNames.Fields.MIME_TYPE.name(), mediaType);
         dbVideo.put(DbNames.Fields.MIME_SUBTYPE.name(), mediaSubType);
         DBCollection dbVideos = getVideoCollection();
         dbVideos.insert(dbVideo);
+        return ((ObjectId) dbVideo.get(DbNames.Fields._id.name())).toString();
     }
 
     private DBCollection getVideoCollection() {
@@ -49,28 +58,31 @@ public class MediaDBImpl implements MediaDB {
     }
 
     @Override
-    public DBMediaTrack loadMediaTrack(String videoTitle) {
-        DBCursor cursor = getVideoCollection().find(new BasicDBObject(DbNames.Fields.MEDIA_TITLE.name(), videoTitle));
+    public DBMediaTrack loadMediaTrack(String dbId) {
+        ObjectId objectId = new ObjectId(dbId);
+        DBCursor cursor = getVideoCollection().find(new BasicDBObject(DbNames.Fields._id.name(), objectId));
         switch (cursor.count()) {
         case 0:
-            throw new RuntimeException("Video not found with title: " + videoTitle);
+            throw new RuntimeException("Video not found with id: " + dbId);
         case 1:
             DBObject dbObject = cursor.next();
             DBMediaTrack dbMediaTrack = createMediaObjectFromDB(dbObject);
             return dbMediaTrack;
         default:
-            throw new RuntimeException("Ambiguous videos not found with title: " + videoTitle);
+            throw new RuntimeException("Ambiguous videos not found with id: " + dbId);
 
         }
     }
 
     private DBMediaTrack createMediaObjectFromDB(DBObject dbObject) {
+        String dbId = ((ObjectId) dbObject.get(DbNames.Fields._id.name())).toString();
         String title = (String) dbObject.get(DbNames.Fields.MEDIA_TITLE.name());
         String url = (String) dbObject.get(DbNames.Fields.MEDIA_URL.name());
         Date startTime = (Date) dbObject.get(DbNames.Fields.STARTTIME.name());
+        Integer durationInMillis = (Integer) dbObject.get(DbNames.Fields.DURATION_IN_MILLIS.name());
         String mimeType = (String) dbObject.get(DbNames.Fields.MIME_TYPE.name());
         String mimeSubType = (String) dbObject.get(DbNames.Fields.MIME_SUBTYPE.name());
-        DBMediaTrack dbMediaTrack = new DBMediaTrack(title, url, startTime, mimeType, mimeSubType);
+        DBMediaTrack dbMediaTrack = new DBMediaTrack(dbId, title, url, startTime, durationInMillis == null ? 0 : durationInMillis, mimeType, mimeSubType);
         return dbMediaTrack;
     }
 
@@ -85,9 +97,57 @@ public class MediaDBImpl implements MediaDB {
     }
 
     @Override
-    public void deleteMediaTrack(String title) {
+    public void deleteMediaTrack(String dbId) {
         BasicDBObject dbObject = new BasicDBObject();
-        dbObject.put(DbNames.Fields.MEDIA_TITLE.name(), title);
+        dbObject.put(DbNames.Fields._id.name(), new ObjectId(dbId));
         getVideoCollection().remove(dbObject);
     }
+
+    @Override
+    public void updateStartTime(String dbId, Date startTime) {
+        BasicDBObject updateQuery = new BasicDBObject();
+        updateQuery.append(DbNames.Fields._id.name(), new ObjectId(dbId));
+
+        BasicDBObject update = new BasicDBObject();
+        update.append("$set", new BasicDBObject(DbNames.Fields.STARTTIME.name(), startTime));
+
+        getVideoCollection().update(updateQuery, update);
+    }
+
+    @Override
+    public void updateDuration(String dbId, int durationInMillis) {
+        BasicDBObject updateQuery = new BasicDBObject();
+        updateQuery.append(DbNames.Fields._id.name(), new ObjectId(dbId));
+
+        BasicDBObject update = new BasicDBObject();
+        update.append("$set", new BasicDBObject(DbNames.Fields.DURATION_IN_MILLIS.name(), durationInMillis));
+
+        getVideoCollection().update(updateQuery, update);
+    }
+
+    @Override
+    public Collection<DBMediaTrack> queryOverlappingMediaTracks(Date rangeStart, Date rangeEnd) {
+        BasicDBObject startTimeCondition = new BasicDBObject();
+        startTimeCondition.put(DbNames.Fields.STARTTIME.name(), new BasicDBObject("$gt", rangeStart));
+        startTimeCondition.put(DbNames.Fields.STARTTIME.name(), new BasicDBObject("$lt", rangeEnd));
+        BasicDBObject endTimeCondition = new BasicDBObject();
+        
+        // Should actually be "AND greater than rangeStart - duration".
+        // However, using values calculated on server side turns out to be a nightmare with mongodb.
+        // Instead do the remaining filtering on client side...
+        endTimeCondition.put(DbNames.Fields.STARTTIME.name(), new BasicDBObject("$lt", rangeStart));
+
+        DBObject query = QueryBuilder.start().or(startTimeCondition, endTimeCondition).get(); 
+        DBCursor cursor = getVideoCollection().find(query);
+        
+        List<DBMediaTrack> result = new ArrayList<>(cursor.count());
+        while (cursor.hasNext()) {
+            DBMediaTrack resultCandidate = createMediaObjectFromDB(cursor.next());
+            if (resultCandidate.durationInMillis > rangeStart.getTime() - resultCandidate.startTime.getTime()) {
+                result.add(resultCandidate);
+            }
+        }
+        return result;
+    }
+    
 }

java/com.sap.sailing.domain.persistence/src/com/sap/sailing/domain/persistence/media/impl/MediaObjectFactoryImpl.java

@@ -1,19 +1,17 @@
 package com.sap.sailing.domain.persistence.media.impl;
 
-import java.util.logging.Logger;
-
 import com.mongodb.DB;
 import com.sap.sailing.domain.persistence.media.MediaObjectFactory;
 
 public class MediaObjectFactoryImpl implements MediaObjectFactory {
 
-    private static final Logger logger = Logger.getLogger(MediaObjectFactoryImpl.class.getName());
+//    private static final Logger logger = Logger.getLogger(MediaObjectFactoryImpl.class.getName());
 
-    private final DB database;
+//    private final DB database;
 
     public MediaObjectFactoryImpl(DB db) {
         super();
-        this.database = db;
+//        this.database = db;
     }
 
 }

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/adminconsole/MediaPanel.java

@@ -1,7 +1,7 @@
 package com.sap.sailing.gwt.ui.adminconsole;
 
+import java.util.Collection;
 import java.util.Comparator;
-import java.util.List;
 
 import com.google.gwt.cell.client.ActionCell;
 import com.google.gwt.cell.client.EditTextCell;
@@ -38,7 +38,7 @@ import com.sap.sailing.gwt.ui.shared.media.MediaTrack;
  */
 public class MediaPanel extends FlowPanel {
 
-    private static final DateTimeFormat TIME_FORMAT = DateTimeFormat.getFormat(PredefinedFormat.HOUR24_MINUTE_SECOND);
+//    private static final DateTimeFormat TIME_FORMAT = DateTimeFormat.getFormat(PredefinedFormat.HOUR24_MINUTE_SECOND);
     private static final DateTimeFormat DATETIME_FORMAT = DateTimeFormat.getFormat(PredefinedFormat.DATE_TIME_MEDIUM);
     // private Calendar calender = new GregorianCalendar();
 
@@ -80,7 +80,7 @@ public class MediaPanel extends FlowPanel {
 
     protected void loadMediaTracks() {
         mediaTrackListDataProvider.getList().clear();
-        mediaService.getAllMediaTracks(new AsyncCallback<List<MediaTrack>>() {
+        mediaService.getAllMediaTracks(new AsyncCallback<Collection<MediaTrack>>() {
 
             @Override
             public void onFailure(Throwable t) {
@@ -88,7 +88,7 @@ public class MediaPanel extends FlowPanel {
             }
 
             @Override
-            public void onSuccess(List<MediaTrack> allMediaTracks) {
+            public void onSuccess(Collection<MediaTrack> allMediaTracks) {
                 mediaTrackListDataProvider.getList().addAll(allMediaTracks);
                 mediaTrackListDataProvider.refresh();
             }
@@ -255,12 +255,57 @@ public class MediaPanel extends FlowPanel {
             public void update(int index, MediaTrack mediaTrack, String newStartTime) {
                 // Called when the user changes the value.
                 mediaTrack.startTime = DATETIME_FORMAT.parse(newStartTime);
-                mediaTrackListDataProvider.refresh();
+                mediaService.updateStartTime(mediaTrack, new AsyncCallback<Void>() {
+
+                    @Override
+                    public void onFailure(Throwable t) {
+                        errorReporter.reportError(t.toString());
+                    }
+
+                    @Override
+                    public void onSuccess(Void allMediaTracks) {
+                        mediaTrackListDataProvider.refresh();
+                    }
+                });
             }
         });
         mediaTracksTable.addColumn(startTimeColumn, stringMessages.startTime());
         mediaTracksTable.setColumnWidth(startTimeColumn, 100, Unit.PCT);
 
+        // duration
+        Column<MediaTrack, String> durationColumn = new Column<MediaTrack, String>(new EditTextCell()) {
+            @Override
+            public String getValue(MediaTrack mediaTrack) {
+                return TimeFormatUtil.milliSecondsToHrsMinSec(mediaTrack.durationInMillis);
+            }
+        };
+        durationColumn.setSortable(true);
+        sortHandler.setComparator(durationColumn, new Comparator<MediaTrack>() {
+            public int compare(MediaTrack mediaTrack1, MediaTrack mediaTrack2) {
+                return Integer.valueOf(mediaTrack1.durationInMillis).compareTo(Integer.valueOf(mediaTrack2.durationInMillis));
+            }
+        });
+        durationColumn.setFieldUpdater(new FieldUpdater<MediaTrack, String>() {
+            public void update(int index, MediaTrack mediaTrack, String newDuration) {
+                // Called when the user changes the value.
+                mediaTrack.durationInMillis = TimeFormatUtil.hrsMinSecToMilliSeconds(newDuration);
+                mediaService.updateDuration(mediaTrack, new AsyncCallback<Void>() {
+
+                    @Override
+                    public void onFailure(Throwable t) {
+                        errorReporter.reportError(t.toString());
+                    }
+
+                    @Override
+                    public void onSuccess(Void allMediaTracks) {
+                        mediaTrackListDataProvider.refresh();
+                    }
+                });
+            }
+        });
+        mediaTracksTable.addColumn(durationColumn, stringMessages.duration());
+        mediaTracksTable.setColumnWidth(durationColumn, 100, Unit.PCT);
+
         // delete action
         Column<MediaTrack, MediaTrack> deleteActionColumn = new IdentityColumn<MediaTrack>(new ActionCell<MediaTrack>("X", new ActionCell.Delegate<MediaTrack>() {
             @Override

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/adminconsole/MediaTrackDialog.java

@@ -2,8 +2,10 @@ package com.sap.sailing.gwt.ui.adminconsole;
 
 import java.util.Date;
 
+import com.google.gwt.dom.client.VideoElement;
 import com.google.gwt.event.dom.client.ChangeEvent;
 import com.google.gwt.event.dom.client.ChangeHandler;
+import com.google.gwt.media.client.Video;
 import com.google.gwt.user.client.rpc.AsyncCallback;
 import com.google.gwt.user.client.ui.Grid;
 import com.google.gwt.user.client.ui.Label;
@@ -64,10 +66,37 @@ public class MediaTrackDialog extends DataEntryDialog<MediaTrack> {
         String title = nameBox.getValue();
         String url = urlBox.getValue();
         Date startTime = startTimeBox.getValue();
-        MediaTrack result = new MediaTrack(title, url, startTime, mediaType, mediaSubType);
+        int durationInMillis = getMediaDuration(url, mediaType, mediaSubType);
+        MediaTrack result = new MediaTrack(title, url, startTime, durationInMillis, mediaType, mediaSubType);
         return result;
     }
 
+    private int getMediaDuration(String url, MediaType mediaType, MediaSubType mediaSubType) {
+        if (mediaType != null) {
+            switch (mediaType) {
+            case VIDEO:
+                Video videoControl = Video.createIfSupported();
+                if (videoControl != null) {
+                    videoControl.setSrc(url);
+                    VideoElement videoElement = videoControl.getVideoElement();
+                    double result = videoElement.getDuration();
+                    videoElement.play();
+
+                    long timeout = System.currentTimeMillis() + 5 * 1000;
+                    while (System.currentTimeMillis() < timeout) {
+                        if (videoElement.getReadyState() > 0) {
+                            return (int) Math.round(videoElement.getDuration() * 1000);
+                        }
+                    }
+                }
+            default:
+                return 0;
+            }
+        } else {
+            return 0;
+        }
+    }
+
     @Override
     protected Widget getAdditionalWidget() {
         VerticalPanel mainPanel = new VerticalPanel();

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/adminconsole/TimeFormatUtil.java

@@ -0,0 +1,38 @@
+package com.sap.sailing.gwt.ui.adminconsole;
+
+import com.google.gwt.i18n.client.NumberFormat;
+import com.sap.sailing.gwt.ui.client.NumberFormatterFactory;
+
+public class TimeFormatUtil {
+    
+    private static NumberFormat zeroPaddingNumberFormat_Min = NumberFormatterFactory.getDecimalFormat(2, 0);
+    private static NumberFormat zeroPaddingNumberFormat_Sec = NumberFormatterFactory.getDecimalFormat(2, 3);
+
+    public static int hrsMinSecToMilliSeconds(String hrsMinSec) {
+        String[] segements = hrsMinSec.split(":");
+        int milliseconds = 0;
+        switch (segements.length) {
+        case 3:
+            String hours = segements[0].trim();
+            milliseconds = Integer.valueOf(hours) * 60 * 60 * 1000;
+        case 2:
+            String minutes = segements[segements.length - 2].trim();
+            milliseconds = milliseconds + Integer.valueOf(minutes) * 60 * 1000;
+        case 1:
+            String seconds = segements[segements.length - 1].trim();
+            milliseconds = milliseconds + Math.round(Float.valueOf(seconds) * 1000);
+        }
+        return milliseconds;
+    }
+
+    public static String milliSecondsToHrsMinSec(int milliseconds) {
+        int hours = (milliseconds / (60 * 60 * 1000));
+        int rest = (milliseconds % (60 * 60 * 1000));
+        int minutes = (rest / (60 * 1000));
+        rest = (rest % (60 * 1000));
+        double seconds = (double) rest / 1000;
+        String result = String.valueOf(hours) + ':' + zeroPaddingNumberFormat_Min.format(minutes) + ':' + zeroPaddingNumberFormat_Sec.format(seconds);
+        return result;
+    }
+
+}

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/MediaService.java

@@ -13,10 +13,14 @@ public interface MediaService extends RemoteService {
 
     Collection<MediaTrack> getMediaTracksForRace(RegattaAndRaceIdentifier regattaAndRaceIdentifier);
 
-    List<MediaTrack> getAllMediaTracks();
+    Collection<MediaTrack> getAllMediaTracks();
 
     void addMediaTrack(MediaTrack mediaTrack);
 
     void deleteMediaTrack(MediaTrack mediaTrack);
 
+    void updateStartTime(MediaTrack mediaTrack);
+
+    void updateDuration(MediaTrack mediaTrack);
+
 }

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/MediaServiceAsync.java

@@ -12,10 +12,14 @@ public interface MediaServiceAsync {
     void getMediaTracksForRace(RegattaAndRaceIdentifier regattaAndRaceIdentifier,
             AsyncCallback<Collection<MediaTrack>> callback);
 
-    void getAllMediaTracks(AsyncCallback<List<MediaTrack>> asyncCallback);
+    void getAllMediaTracks(AsyncCallback<Collection<MediaTrack>> asyncCallback);
 
     void addMediaTrack(MediaTrack mediaTrack, AsyncCallback<Void> asyncCallback);
 
     void deleteMediaTrack(MediaTrack mediaTrack, AsyncCallback<Void> asyncCallback);
 
+    void updateStartTime(MediaTrack mediaTrack, AsyncCallback<Void> asyncCallback);
+
+    void updateDuration(MediaTrack mediaTrack, AsyncCallback<Void> asyncCallback);
+
 }

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages.java

@@ -1,6 +1,7 @@
 package com.sap.sailing.gwt.ui.client;
 
 import com.google.gwt.i18n.client.Messages;
+import com.google.gwt.user.cellview.client.Header;
 
 public interface StringMessages extends Messages {
     String helloWorld();
@@ -404,4 +405,5 @@ public interface StringMessages extends Messages {
     String mimeType();
     String title();
     String reallyRemoveMediaTrack(String mediaTrackTitle);
+    String duration();
 }

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages.properties

@@ -403,4 +403,5 @@ mediaPanel=Audio & Video
 url=URL
 mimeType=MIME Type
 title=Title
-reallyRemoveMediaTrack=Do you really want to remove media track ''{0}''?
+reallyRemoveMediaTrack=Do you really want to remove media track ''{0}''?
+duration=Duration (h:mm:ss.ms)

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages_de.properties

@@ -404,4 +404,5 @@ mediaPanel=Audio & Video
 url=URL
 mimeType=MIME Type
 title=Titel
-reallyRemoveMediaTrack=Möchten Sie ''{0}'' wirklich entfernen?
+reallyRemoveMediaTrack=Möchten Sie ''{0}'' wirklich entfernen?
+duration=Dauer (h:mm:ss.ms)

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/server/MediaServiceImpl.java

@@ -4,44 +4,59 @@ import java.text.DateFormat;
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
+import java.util.Date;
 import java.util.List;
-import java.util.logging.Logger;
+
+import org.osgi.framework.BundleContext;
+import org.osgi.util.tracker.ServiceTracker;
 
 import com.google.gwt.user.server.rpc.RemoteServiceServlet;
 import com.sap.sailing.domain.common.RegattaAndRaceIdentifier;
 import com.sap.sailing.domain.persistence.media.DBMediaTrack;
 import com.sap.sailing.domain.persistence.media.MediaDB;
 import com.sap.sailing.domain.persistence.media.MediaDBFactory;
+import com.sap.sailing.domain.tracking.TrackedRace;
 import com.sap.sailing.gwt.ui.client.MediaService;
 import com.sap.sailing.gwt.ui.shared.media.MediaTrack;
 import com.sap.sailing.gwt.ui.shared.media.MediaTrack.MediaSubType;
 import com.sap.sailing.gwt.ui.shared.media.MediaTrack.MediaType;
+import com.sap.sailing.server.RacingEventService;
 
 public class MediaServiceImpl extends RemoteServiceServlet implements MediaService {
 
-    private static final Logger logger = Logger.getLogger(MediaServiceImpl.class.getName());
+//    private static final Logger logger = Logger.getLogger(MediaServiceImpl.class.getName());
 
     DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss Z");
 
+    private ServiceTracker<RacingEventService, RacingEventService> racingEventServiceTracker;
+
     private static final long serialVersionUID = -8917349579281305977L;
 
     public MediaServiceImpl() {
         super();
+        BundleContext context = Activator.getDefault();
+        racingEventServiceTracker = new ServiceTracker<RacingEventService, RacingEventService>(
+                context, RacingEventService.class.getName(), null);
+        racingEventServiceTracker.open();
     }
 
     @Override
     public Collection<MediaTrack> getMediaTracksForRace(RegattaAndRaceIdentifier regattaAndRaceIdentifier) {
-        return getAllMediaTracks();
+        TrackedRace trackedRace = racingEventServiceTracker.getService().getExistingTrackedRace(regattaAndRaceIdentifier);
+        if (trackedRace != null) {
+            Date raceStart = trackedRace.getStartOfTracking().asDate();
+            Date raceEnd = trackedRace.getStartOfTracking().asDate();
+            return createMediaTracksFromDB(mediaDB().queryOverlappingMediaTracks(raceStart , raceEnd));
+        } else {
+            return Collections.emptyList();
+        }
     }
 
     @Override
-    public List<MediaTrack> getAllMediaTracks() {
+    public Collection<MediaTrack> getAllMediaTracks() {
         List<DBMediaTrack> allDBMediaTracks = mediaDB().loadAllMediaTracks();
-        List<MediaTrack> result = new ArrayList<MediaTrack>();
-        for (DBMediaTrack dbMediaTrack : allDBMediaTracks) {
-            MediaTrack mediaTrack = createMediaTrackFromDB(dbMediaTrack);
-            result.add(mediaTrack );
-        }
+        Collection<MediaTrack> result = createMediaTracksFromDB(allDBMediaTracks);
         return result;
 //        try {
 //            Date date = dateFormat.parse("2012-09-15 14:42:10 +0100");
@@ -56,16 +71,25 @@ public class MediaServiceImpl extends RemoteServiceServlet implements MediaServi
 //        }
     }
 
+    private Collection<MediaTrack> createMediaTracksFromDB(Collection<DBMediaTrack> allDBMediaTracks) {
+        Collection<MediaTrack> result = new ArrayList<MediaTrack>();
+        for (DBMediaTrack dbMediaTrack : allDBMediaTracks) {
+            MediaTrack mediaTrack = createMediaTrackFromDB(dbMediaTrack);
+            result.add(mediaTrack );
+        }
+        return result;
+    }
+
     private MediaTrack createMediaTrackFromDB(DBMediaTrack dbMediaTrack) {
         MediaType mediaType = MediaType.valueOf(dbMediaTrack.mimeType);
         MediaSubType mediaSubType = MediaSubType.valueOf(dbMediaTrack.mimeSubType);
-        MediaTrack mediaTrack = new MediaTrack(dbMediaTrack.title, dbMediaTrack.url, dbMediaTrack.startTime, mediaType, mediaSubType);
+        MediaTrack mediaTrack = new MediaTrack(dbMediaTrack.dbId, dbMediaTrack.title, dbMediaTrack.url, dbMediaTrack.startTime, dbMediaTrack.durationInMillis, mediaType, mediaSubType);
         return mediaTrack;
     }
 
     @Override
     public void addMediaTrack(MediaTrack mediaTrack) {
-        mediaDB().insertMediaTrack(mediaTrack.title, mediaTrack.url, mediaTrack.startTime, mediaTrack.type.name(), mediaTrack.subType.name());
+        mediaDB().insertMediaTrack(mediaTrack.title, mediaTrack.url, mediaTrack.startTime, mediaTrack.durationInMillis, mediaTrack.type.name(), mediaTrack.subType.name());
     }
 
     private MediaDB mediaDB() {
@@ -74,6 +98,16 @@ public class MediaServiceImpl extends RemoteServiceServlet implements MediaServi
 
     @Override
     public void deleteMediaTrack(MediaTrack mediaTrack) {
-        mediaDB().deleteMediaTrack(mediaTrack.title);
+        mediaDB().deleteMediaTrack(mediaTrack.dbId);
+    }
+
+    @Override
+    public void updateStartTime(MediaTrack mediaTrack) {
+        mediaDB().updateStartTime(mediaTrack.dbId, mediaTrack.startTime);
+    }
+
+    @Override
+    public void updateDuration(MediaTrack mediaTrack) {
+        mediaDB().updateDuration(mediaTrack.dbId, mediaTrack.durationInMillis);
     }
 }

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/shared/media/MediaTrack.java

@@ -44,9 +44,11 @@ public class MediaTrack implements IsSerializable {
         public Date endTime;
     }
 
+    public String dbId;
     public String title;
     public String url;
     public Date startTime;
+    public int durationInMillis;
     public MediaType type;
     public MediaSubType subType;
 
@@ -54,13 +56,20 @@ public class MediaTrack implements IsSerializable {
         super();
     }
 
-    public MediaTrack(String title, String url, Date startTime, MediaType type, MediaSubType subType) {
+    public MediaTrack(String title, String url, Date startTime, int durationInMillis, MediaType mediaType, MediaSubType mediaSubType) {
+        this(null, title, url, startTime, durationInMillis, mediaType, mediaSubType);
+    }
+
+    public MediaTrack(String dbId, String title, String url, Date startTime, int durationInMillis, MediaType mediaType,
+            MediaSubType mediaSubType) {
         super();
+        this.dbId = dbId;
         this.title = title;
         this.url = url;
         this.startTime = startTime;
-        this.type = type;
-        this.subType = subType;
+        this.durationInMillis = durationInMillis;
+        this.type = mediaType;
+        this.subType = mediaSubType;
     }
 
 }

java/com.sap.sailing.media.persistence.test/META-INF/MANIFEST.MF

@@ -12,5 +12,6 @@ Require-Bundle: com.mongodb.driver;bundle-version="2.6.2",
  org.hamcrest.core;bundle-version="1.1.0",
  org.junit4;bundle-version="4.8.2",
  com.sap.sailing.domain.persistence;bundle-version="1.0.0",
- com.sap.sailing.gwt.ui;bundle-version="1.0.0"
+ com.sap.sailing.gwt.ui;bundle-version="1.0.0",
+ com.sap.sailing.domain.common;bundle-version="1.0.0"
 

java/com.sap.sailing.media.persistence.test/src/com/sap/sailing/media/persistence/test/TestCRUDMedia.java

@@ -1,90 +0,0 @@
-package com.sap.sailing.media.persistence.test;
-
-import java.net.UnknownHostException;
-import java.util.Date;
-import java.util.List;
-import java.util.logging.Logger;
-
-import org.hamcrest.core.Is;
-import org.junit.Test;
-
-import com.mongodb.MongoException;
-import com.sap.sailing.domain.persistence.media.DBMediaTrack;
-import com.sap.sailing.domain.persistence.media.MediaDB;
-import com.sap.sailing.domain.persistence.media.MediaDBFactory;
-import com.sap.sailing.gwt.ui.shared.media.MediaTrack.MediaSubType;
-import com.sap.sailing.gwt.ui.shared.media.MediaTrack.MediaType;
-
-import static junit.framework.Assert.assertNotNull;
-
-import static org.junit.Assert.assertThat;
-
-public class TestCRUDMedia extends AbstractMongoDBTest {
-
-    private static final Logger logger = Logger.getLogger(TestCRUDMedia.class.getName());
-
-    public TestCRUDMedia() throws UnknownHostException, MongoException {
-        super();
-    }
-
-    @Test
-    public void testCreateVideoTrack() {
-        final String videoTitle = "Test Video";
-        final String url = "http://localhost:8888/media/HTML5/1809147112001_1842870496001_SAP-Regatta-Day02-Final_libtheora.ogv";
-        MediaDB mongoDB = MediaDBFactory.INSTANCE.getMediaDB(getMongoService());
-        Date date = new Date();
-        String mediaType = MediaType.VIDEO.name();
-        String mediaSubType = MediaSubType.ogg.name();
-        mongoDB.insertMediaTrack(videoTitle, url, date, mediaType, mediaSubType);
-        DBMediaTrack videoTrack = mongoDB.loadMediaTrack(videoTitle);
-        assertNotNull(videoTrack);
-        assertThat(videoTrack.title, Is.is(videoTitle));
-    }
-
-    @Test(expected = RuntimeException.class)
-    public void testFailReadMissingVideoTrack() {
-        final String videoTitle = "Test Video";
-        MediaDB mongoDB = MediaDBFactory.INSTANCE.getMediaDB(getMongoService());
-        mongoDB.loadMediaTrack(videoTitle);
-    }
-
-    @Test
-    public void testLoadAllVideoTracks() {
-        MediaDB mongoDB = MediaDBFactory.INSTANCE.getMediaDB(getMongoService());
-        int testEntryCount = 10;
-        storeNumberOfTestMediaTracks(mongoDB, testEntryCount);
-        List<DBMediaTrack> allMediaTracks = mongoDB.loadAllMediaTracks();
-        assertThat(allMediaTracks.size(), org.hamcrest.core.Is.is(testEntryCount));
-    }
-
-    private void storeNumberOfTestMediaTracks(MediaDB mongoDB, int count) {
-        final String videoTitleTemplate = "Test Video ";
-        final String url = "http://localhost:8888/media/HTML5/1809147112001_1842870496001_SAP-Regatta-Day02-Final_libtheora.ogv";
-        Date date = new Date();
-        String mediaType = MediaType.VIDEO.name();
-        String mediaSubType = MediaSubType.ogg.name();
-
-        for (int i = 0; i < count; i++) {
-            mongoDB.insertMediaTrack(videoTitleTemplate + i, url, date, mediaType, mediaSubType);
-        }
-    }
-
-    @Test(expected=RuntimeException.class)
-    public void testDeleteVideoTrack() {
-        //insert test object
-        final String videoTitle = "Test Video";
-        final String url = "test";
-        MediaDB mongoDB = MediaDBFactory.INSTANCE.getMediaDB(getMongoService());
-        Date date = new Date();
-        String mediaType = MediaType.VIDEO.name();
-        String mediaSubType = MediaSubType.ogg.name();
-        mongoDB.insertMediaTrack(videoTitle, url, date, mediaType, mediaSubType);
-        
-        //delete
-        mongoDB.deleteMediaTrack(videoTitle);
-        
-        //assert not exists --> RuntimeException
-        mongoDB.loadMediaTrack(videoTitle);
-    }
-
-}

java/com.sap.sailing.media.persistence.test/src/com/sap/sailing/media/persistence/test/TestMediaDB.java

@@ -0,0 +1,232 @@
+package com.sap.sailing.media.persistence.test;
+
+import java.net.UnknownHostException;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+
+import org.hamcrest.core.Is;
+import org.junit.Test;
+
+import com.mongodb.MongoException;
+import com.sap.sailing.domain.persistence.media.DBMediaTrack;
+import com.sap.sailing.domain.persistence.media.MediaDB;
+import com.sap.sailing.domain.persistence.media.MediaDBFactory;
+import com.sap.sailing.gwt.ui.shared.media.MediaTrack.MediaSubType;
+import com.sap.sailing.gwt.ui.shared.media.MediaTrack.MediaType;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThat;
+
+import static org.hamcrest.core.Is.is;
+
+public class TestMediaDB extends AbstractMongoDBTest {
+
+    private static final int FIFTEEN_MINUTES_IN_MILLIS = 15 * 60 * 1000;
+    private static final int THIRTY_MINUTES_IN_MILLIS = 30 * 60 * 1000;
+    private static final int ONE_HOUR_IN_MILLIS = 60 * 60 * 1000;
+
+//    private static final Logger logger = Logger.getLogger(TestCRUDMedia.class.getName());
+
+    public TestMediaDB() throws UnknownHostException, MongoException {
+        super();
+    }
+
+    @Test
+    public void testCreateVideoTrack() {
+        final String videoTitle = "Test Video";
+        final String url = "http://localhost:8888/media/HTML5/1809147112001_1842870496001_SAP-Regatta-Day02-Final_libtheora.ogv";
+        MediaDB mongoDB = MediaDBFactory.INSTANCE.getMediaDB(getMongoService());
+        Date date = new Date();
+        int durationInMillis = 23;
+        String mediaType = MediaType.VIDEO.name();
+        String mediaSubType = MediaSubType.ogg.name();
+        String dbId = mongoDB.insertMediaTrack(videoTitle, url, date, durationInMillis, mediaType, mediaSubType);
+        DBMediaTrack videoTrack = mongoDB.loadMediaTrack(dbId);
+        assertNotNull(videoTrack);
+        assertThat(videoTrack.title, Is.is(videoTitle));
+    }
+
+    @Test(expected = RuntimeException.class)
+    public void testFailReadMissingVideoTrack() {
+        final String dbId = "non-existing id";
+        MediaDB mongoDB = MediaDBFactory.INSTANCE.getMediaDB(getMongoService());
+        mongoDB.loadMediaTrack(dbId);
+    }
+
+    @Test
+    public void testLoadAllVideoTracks() {
+        MediaDB mongoDB = MediaDBFactory.INSTANCE.getMediaDB(getMongoService());
+        int testEntryCount = 10;
+        storeNumberOfTestMediaTracks(mongoDB, testEntryCount);
+        List<DBMediaTrack> allMediaTracks = mongoDB.loadAllMediaTracks();
+        assertThat(allMediaTracks.size(), is(testEntryCount));
+    }
+
+    private void storeNumberOfTestMediaTracks(MediaDB mongoDB, int count) {
+        final String videoTitleTemplate = "Test Video ";
+        final String url = "http://localhost:8888/media/HTML5/1809147112001_1842870496001_SAP-Regatta-Day02-Final_libtheora.ogv";
+        Date date = new Date();
+        int durationInMillis = 23;
+        String mediaType = MediaType.VIDEO.name();
+        String mediaSubType = MediaSubType.ogg.name();
+
+        for (int i = 0; i < count; i++) {
+            mongoDB.insertMediaTrack(videoTitleTemplate + i, url, date, durationInMillis, mediaType, mediaSubType);
+        }
+    }
+
+    @Test(expected=RuntimeException.class)
+    public void testDeleteVideoTrack() {
+        //insert test object
+        final String videoTitle = "Test Video";
+        final String url = "test";
+        MediaDB mongoDB = MediaDBFactory.INSTANCE.getMediaDB(getMongoService());
+        Date date = new Date();
+        int durationInMillis = 23;
+        String mediaType = MediaType.VIDEO.name();
+        String mediaSubType = MediaSubType.ogg.name();
+        String dbId = mongoDB.insertMediaTrack(videoTitle, url, date, durationInMillis, mediaType, mediaSubType);
+        
+        //delete
+        mongoDB.deleteMediaTrack(videoTitle);
+        
+        //assert not exists --> RuntimeException
+        mongoDB.loadMediaTrack(dbId);
+    }
+
+    @Test
+    public void testUpdateStartTime() {
+        //insert test object
+        final String videoTitle = "Test Video";
+        final String url = "test";
+        MediaDB mongoDB = MediaDBFactory.INSTANCE.getMediaDB(getMongoService());
+        Date originalDate = new Date();
+        int durationInMillis = 23;
+        String mediaType = MediaType.VIDEO.name();
+        String mediaSubType = MediaSubType.ogg.name();
+        String dbId = mongoDB.insertMediaTrack(videoTitle, url, originalDate, durationInMillis, mediaType, mediaSubType);
+        
+        //update with new date
+        Date newDate = new Date(originalDate.getTime() + 1000);
+        mongoDB.updateStartTime(dbId, newDate);
+        
+        //assert start time is updated and everything else preserved
+        DBMediaTrack videoTrack = mongoDB.loadMediaTrack(dbId);
+        assertThat(videoTrack.startTime, is(newDate));
+        assertThat(videoTrack.durationInMillis, is(durationInMillis));
+        assertThat(videoTrack.title, is(videoTitle));
+        assertThat(videoTrack.url, is(url));
+        assertThat(videoTrack.mimeType, is(mediaType));
+        assertThat(videoTrack.mimeSubType, is(mediaSubType));
+    }
+    
+    
+    @Test
+    public void testQueryMediaTracksBetween_MatchingStartTimes_TrackLongerThanEndTime() {
+        Date startTime = new Date();
+        int duration = ONE_HOUR_IN_MILLIS;
+        Date rangeStart = startTime;
+        Date rangeEnd = new Date(rangeStart.getTime() + THIRTY_MINUTES_IN_MILLIS);
+
+        assertOverlap(startTime, duration, rangeStart, rangeEnd);
+    }
+
+    @Test
+    public void testQueryMediaTracksBetween_MatchingStartTimes_TrackShorterThanEndTime() {
+        Date startTime = new Date();
+        int duration = THIRTY_MINUTES_IN_MILLIS;
+        Date rangeStart = startTime;
+        Date rangeEnd = new Date(rangeStart.getTime() + ONE_HOUR_IN_MILLIS);
+
+        assertOverlap(startTime, duration, rangeStart, rangeEnd);
+    }
+    
+    @Test
+    public void testQueryMediaTracksBetween_StartsBeforeEndsAfterRange() {
+        Date startTime = new Date();
+        int duration = ONE_HOUR_IN_MILLIS;
+        Date rangeStart = new Date(startTime.getTime() + FIFTEEN_MINUTES_IN_MILLIS);
+        Date rangeEnd = new Date(rangeStart.getTime() + FIFTEEN_MINUTES_IN_MILLIS);
+
+        assertOverlap(startTime, duration, rangeStart, rangeEnd);
+    }
+    
+    @Test
+    public void testQueryMediaTracksBetween_StartsAfterEndsBeforeRange() {
+        Date rangeStart = new Date();
+        Date rangeEnd = new Date(rangeStart.getTime() + ONE_HOUR_IN_MILLIS);
+        Date startTime = new Date(rangeStart.getTime() + FIFTEEN_MINUTES_IN_MILLIS);
+        int duration = FIFTEEN_MINUTES_IN_MILLIS;
+
+        assertOverlap(startTime, duration, rangeStart, rangeEnd);
+    }
+    
+    @Test
+    public void testQueryMediaTracksBetween_StartsAfterEndsAfterRange() {
+        Date rangeStart = new Date();
+        Date rangeEnd = new Date(rangeStart.getTime() + THIRTY_MINUTES_IN_MILLIS);
+        Date startTime = new Date(rangeStart.getTime() + FIFTEEN_MINUTES_IN_MILLIS);
+        int duration = THIRTY_MINUTES_IN_MILLIS;
+
+        assertOverlap(startTime, duration, rangeStart, rangeEnd);
+    }
+    
+    @Test
+    public void testQueryMediaTracksBetween_StartsBeforeEndsBeforeRange() {
+        Date startTime = new Date();
+        int duration = THIRTY_MINUTES_IN_MILLIS;
+        Date rangeStart = new Date(startTime.getTime() + FIFTEEN_MINUTES_IN_MILLIS);
+        Date rangeEnd = new Date(rangeStart.getTime() + THIRTY_MINUTES_IN_MILLIS);
+
+        assertOverlap(startTime, duration, rangeStart, rangeEnd);
+    }
+    
+    @Test
+    public void testQueryMediaTracksBetween_TrackEndsBeforeRange() {
+        Date startTime = new Date();
+        int duration = THIRTY_MINUTES_IN_MILLIS;
+        Date rangeStart = new Date(startTime.getTime() + duration + 1);
+        Date rangeEnd = new Date(rangeStart.getTime() + ONE_HOUR_IN_MILLIS);
+
+        assertNoOverlap(startTime, duration, rangeStart, rangeEnd);
+    }
+    
+    @Test
+    public void testQueryMediaTracksBetween_TrackStartsAfterRange() {
+        Date rangeStart = new Date();
+        Date rangeEnd = new Date(rangeStart.getTime() + THIRTY_MINUTES_IN_MILLIS);
+        Date startTime = new Date(rangeStart.getTime() + ONE_HOUR_IN_MILLIS);
+        int duration = THIRTY_MINUTES_IN_MILLIS;
+
+        assertNoOverlap(startTime, duration, rangeStart, rangeEnd);
+    }
+    
+    private void assertOverlap(Date startTime, int oneHourInMillis, Date rangeStart, Date rangeEnd) {
+        //insert test object
+        final String videoTitle = "Test Video";
+        final String url = "test";
+        MediaDB mongoDB = MediaDBFactory.INSTANCE.getMediaDB(getMongoService());
+        String mediaType = MediaType.VIDEO.name();
+        String mediaSubType = MediaSubType.ogg.name();
+        String dbId = mongoDB.insertMediaTrack(videoTitle, url, startTime, oneHourInMillis, mediaType, mediaSubType);
+        
+        Collection<DBMediaTrack> videoTracks = mongoDB.queryOverlappingMediaTracks(rangeStart, rangeEnd);
+        assertThat(videoTracks.size(), is(1));
+        assertThat(videoTracks.iterator().next().dbId, is(dbId));
+    }
+    
+    private void assertNoOverlap(Date startTime, int oneHourInMillis, Date rangeStart, Date rangeEnd) {
+        //insert test object
+        final String videoTitle = "Test Video";
+        final String url = "test";
+        MediaDB mongoDB = MediaDBFactory.INSTANCE.getMediaDB(getMongoService());
+        String mediaType = MediaType.VIDEO.name();
+        String mediaSubType = MediaSubType.ogg.name();
+        String dbId = mongoDB.insertMediaTrack(videoTitle, url, startTime, oneHourInMillis, mediaType, mediaSubType);
+        
+        Collection<DBMediaTrack> videoTracks = mongoDB.queryOverlappingMediaTracks(rangeStart, rangeEnd);
+        assertThat(videoTracks.size(), is(0));
+    }
+    
+}