Time estimation algorithm

production_control/models.py

@@ -1,5 +1,6 @@
 from django.db import models
 import uuid
+import datetime
 
 # example json: https://pretalx.margau.net/dtjhhnfm2022/schedule/export/schedule.json
 
@@ -45,3 +46,65 @@ class EndCondition(models.IntegerChoices):
 	actual_duration = models.IntegerField(blank=True, null=True)
 	start = models.IntegerField(choices=StartCondition.choices, default=0)
 	end = models.IntegerField(choices=EndCondition.choices, default=0)
+
+	@property
+	def planned_end(self):
+		end = self.planned_start + datetime.timedelta(0, self.planned_duration)
+		return end
+
+	@property
+	def actual_end(self):
+		end = 0
+		if self.actual_start and self.actual_duration:
+			end = self.actual_start + datetime.timedelta(0, self.actual_duration)
+		return end
+
+	@property
+	def delay_seconds(self):
+		delay_seconds = 0
+		i = 0
+		all_performances = Performance.objects.filter(venue=self.venue).order_by("planned_start")
+		# loop over all performances to find delay
+		while i < len(all_performances):
+			p = all_performances[i]
+
+			# default case: no actual data available
+			# first case: we are running, have no actual end yet, so the delay 
+			if p.actual_start:
+				delay_seconds = (p.actual_start-p.planned_start).total_seconds()
+			# if we are already done, set the end delay
+			if p.actual_end:
+				delay_seconds = (p.actual_end-p.planned_end).total_seconds()
+
+			# if we are not the first check
+			if i > 0 and all_performances[i-1]:
+				# if our start is later or equal than the previous estimated end, no delay is left
+				if p.planned_start >= all_performances[i-1].estimated_end:
+					delay_seconds = 0
+				# otherwise, the delay is the time delay between the prev. end and our planned start
+				else:
+					delay_seconds = (all_performances[i-1].estimated_end - p.planned_start).total_seconds()
+
+			# if this is our searched performance, stop here
+			if p.id == self.id:
+				return delay_seconds
+
+			i+=1
+
+		return delay_seconds
+
+	@property
+	def estimated_start(self):
+		ret = 0
+		# if we already have an actual start, that is our estimated start
+		if self.actual_start:
+			ret = self.actual_start
+		else:
+			ret = self.planned_start + datetime.timedelta(0, self.delay_seconds)
+		return ret
+
+	@property
+	def estimated_end(self):
+		if self.actual_end:
+			return self.actual_end
+		return self.planned_end + datetime.timedelta(0, self.delay_seconds)

production_control/serializers.py

@@ -13,6 +13,12 @@ class Meta:
 		fields = '__all__'
 
 class PerformanceSerializer(serializers.HyperlinkedModelSerializer):
+	planned_end = serializers.ReadOnlyField()
+	actual_end = serializers.ReadOnlyField()
+	estimated_start = serializers.ReadOnlyField()
+	estimated_end = serializers.ReadOnlyField()
+	delay_seconds = serializers.ReadOnlyField()
+
 	class Meta:
 		model = Performance
 		fields = '__all__'

production_control/upstream.py

@@ -28,9 +28,7 @@ def update(event):
 				venue = Venue.objects.get(upstream_name = roomname)
 				for upstream_perf in room:
 					p_start = parser.parse(upstream_perf["start"])
-					print(p_start)
 					p_duration = timeparse(upstream_perf["duration"])*60
-					print(p_duration)
 					p, created = Performance.objects.update_or_create(
 						upstream_uuid = upstream_perf["guid"],
 						defaults={

production_control/views.py

@@ -27,6 +27,11 @@ class VenueViewSet(viewsets.ModelViewSet):
 	queryset = Venue.objects.all()
 	serializer_class = VenueSerializer
 	permission_classes = [permissions.AllowAny]
+	@action(detail=True)
+	def current_timeline(self, request, pk):
+		# todo: Error Handling
+		serializer = PerformanceSerializer(Performance.objects.filter(venue=self.get_object().id).order_by("planned_start"),many=True,context={'request': request})
+		return Response(serializer.data)
 
 class PerformanceViewSet(viewsets.ModelViewSet):
 	"""