added order in daily planning based on officeAvailability which considers...

added order in daily planning based on officeAvailability which considers holidays, extra_availabilities, general appointments from Appointment, and subject assesments from AppointmentTypeLink

smash/web/api_views/worker.py

 import datetime
-
-from django.http import JsonResponse
+import logging
+import json
+from django.http import JsonResponse, HttpResponse
 from django.utils import timezone
 
+from django.shortcuts import get_object_or_404
 from web.models.constants import GLOBAL_STUDY_ID
 from web.api_views.daily_planning import get_workers_for_daily_planning, get_availabilities
 from ..models import Worker
 
+logger = logging.getLogger(__name__)
 
 def specializations(request):
     workers = Worker.objects.filter(specialization__isnull=False).values_list('specialization').distinct()
@@ -21,14 +24,18 @@ def units(request):
         "units": [x[0] for x in workers]
     })
 
-
 def workers_for_daily_planning(request):
+    start_date = request.GET.get('start_date')
     workers = get_workers_for_daily_planning(request)
     workers_list_for_json = []
+    if start_date is not None:
+        today = timezone.now()
+        start_date=datetime.datetime.strptime(start_date, '%Y-%m-%d').replace(tzinfo=today.tzinfo)
     for worker in workers:
         role = unicode(worker.roles.filter(study_id=GLOBAL_STUDY_ID)[0].role)
         worker_dict_for_json = {
             'id': worker.id,
+            'availability': worker.availability_percentage(start_date=start_date),
             'title': u"{} ({})".format(unicode(worker), role[:1].upper()),
             'role': role
         }

smash/web/models/worker.py

@@ -2,6 +2,8 @@
 import datetime
 import logging
 
+from web.utils import get_today_midnight_date
+
 from django.contrib.auth.models import User, AnonymousUser
 from django.db import models
 
@@ -9,6 +11,14 @@ from web.models.constants import GLOBAL_STUDY_ID, COUNTRY_OTHER_ID, AVAILABILITY
 from web.models.worker_study_role import STUDY_ROLE_CHOICES, HEALTH_PARTNER_ROLE_CHOICES, \
     VOUCHER_PARTNER_ROLE_CHOICES, WORKER_STAFF, WORKER_HEALTH_PARTNER, WORKER_VOUCHER_PARTNER, ROLE_CHOICES
 
+from web.utils import get_weekdays_in_period
+from web.officeAvailability import OfficeAvailability
+from django.db.models import Q
+from web.models.holiday import Holiday
+from web.models.availability import Availability
+from web.models.appointment import Appointment
+from web.models.appointment_type_link import AppointmentTypeLink
+
 logger = logging.getLogger(__name__)
 
 
@@ -159,6 +169,48 @@ class Worker(models.Model):
         else:
             return False
 
+    def is_available(self, start_date=None, end_date=None):
+        self.availability_percentage(start_date=start_date, end_date=end_date) > 50.0
+
+    def availability_percentage(self, start_date=None, end_date=None):
+        '''
+            start_date: defaults to None and then is set to today's midnight date 
+            end_date: defaults to None and then is set to today's midnight date + 24 hours
+        '''
+        today_midnight = get_today_midnight_date()
+
+        if start_date is None:
+            start_date = today_midnight
+        if end_date is None:
+            start_date = start_date.replace(hour=0, minute=0, second=0)
+            end_date = start_date + datetime.timedelta(days=1)
+
+        office_availability = OfficeAvailability('{} {}'.format(self.first_name, self.last_name), start=start_date, end=end_date)
+
+        #Appointments
+        subject_appointments = AppointmentTypeLink.objects.filter(worker=self.id, date_when__gte=start_date, date_when__lte=end_date)
+        general_appointments = Appointment.objects.filter(worker_assigned=self.id, datetime_when__gte=start_date, datetime_when__lte=end_date)
+
+        #Holidays and extra availabilities. 
+        holidays_and_extra_availabilities = self.holiday_set.filter(datetime_start__gte=start_date, datetime_end__lt=end_date).order_by('-datetime_start')
+
+        #Availability 
+        weekdays = get_weekdays_in_period(start_date, end_date)
+        weekdayQ = Q() #create a filter for each weekday in the selected period
+        for weekday in weekdays:
+            weekdayQ = weekdayQ | Q(day_number=weekday)
+        availabilities = self.availability_set.filter(person=self.id).filter(weekdayQ).order_by('day_number', 'available_from')
+
+        things = []
+        things.extend(availabilities)
+        things.extend(holidays_and_extra_availabilities)
+        things.extend(subject_appointments)
+        things.extend(general_appointments)
+        for thing in things:
+            office_availability.consider_this(thing, only_working_hours=True)
+
+        return office_availability.get_availability_percentage(only_working_hours=True)
+
     @property
     def role(self):
         roles = self.roles.filter(study=GLOBAL_STUDY_ID)

smash/web/officeAvailability.py

+# coding=utf-8
+import datetime
+from datetime import timedelta
+import logging
+import pandas as pd
+
+from web.utils import timeit, get_today_midnight_date
+from web.models.holiday import Holiday
+from web.models.availability import Availability
+from web.models.appointment import Appointment
+from web.models.appointment_type_link import AppointmentTypeLink
+from web.models.constants import AVAILABILITY_EXTRA, AVAILABILITY_HOLIDAY
+
+logger = logging.getLogger(__name__)
+
+#only for plot method
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+
+class OfficeAvailability(object):
+	'''
+		start: datetime-like indicating when the range starts. If none, then today midnight
+		end: datetime-like indicating when the range ends. If none, then tomorrow midnight
+		office_start: when the office hours begin
+		office_end: when the office hours finish 
+		minimum_slot: frequency of the pandas series. T stands of minutes. Docs: https://pandas.pydata.org/pandas-docs/stable/generated/pandas.date_range.html
+	'''
+	def __init__(self, name, start=None, end=None, office_start='8:00', office_end='19:00', minimum_slot='1T'):
+		today_midnight = get_today_midnight_date()
+		tomorrow_midnight = today_midnight + datetime.timedelta(days=1)
+
+		if start is None:
+			self.start = today_midnight
+		else:
+			self.start = start
+
+		if end is None:
+			self.end = tomorrow_midnight
+		else:
+			self.end = end
+
+		self.name = name
+		self.office_start = office_start
+		self.office_end   = office_end
+		self.minimum_slot = minimum_slot
+		self.range = pd.date_range(start=self.start, end=self.end, freq=self.minimum_slot)
+		logger.debug('Min index: {}. Max index: {}'.format(self.start, self.end))
+		self.availability = pd.Series(index=self.range, data=0) # initialize range at 0
+	
+	def _get_duration(self):
+		return self.availability.index[-1] - self.availability.index[0]
+
+	def add_availability(self, range, only_working_hours=False):
+		if only_working_hours:
+			range = range.to_series().between_time(self.office_start, self.office_end)
+		self.availability[range] = 1
+
+	def remove_availability(self, range, only_working_hours=False):
+		if only_working_hours:
+			range = range.to_series().between_time(self.office_start, self.office_end)
+		self.availability[range] = 0
+
+	def consider_this(self, appointment_availability_or_holiday, only_working_hours=False):
+		'''
+			Availability repeat every week.
+			Availability always refers to a moment in which the worker should be working. Never the opposite.
+			
+			Holiday has higher preference because it refers to extraordinary events like extra availability or lack of availability.
+			Holiday modifies the status of Availability for specific periods of time.
+
+			Only_working_hours: If true changed are limited to the provided working hours.
+
+			Known Issues: If the range to be added extends beyond the limits of the given time series range, the call to self.availability[portion.index] = set_to will fail.
+			It fails because there are keys missing within the time series of the object.
+
+			Two solutions are possible:
+			- First, limit the time periods of the ranges to be considered to the object time space. (current solution)
+			- Second, extend the object time space.
+
+			Notwithstanding, this issue shouldn't exist because in preivous steps we should receive the availabilities queried to the limits of this objects time space.
+			First proposal should be the solution to consider.
+		'''
+		if isinstance(appointment_availability_or_holiday, Availability):
+			start   = appointment_availability_or_holiday.available_from
+			end     = appointment_availability_or_holiday.available_till
+			weekday = appointment_availability_or_holiday.day_number
+			logger.debug('Considering Availability from {} to {} for weekday {}'.format(start, end, weekday))
+			portion = self.availability[self.availability.index.weekday == (weekday-1)].between_time(start,end) #selects the weekdays and then the specific hours
+			set_to  = 1 
+		elif isinstance(appointment_availability_or_holiday, Holiday):
+			start   = appointment_availability_or_holiday.datetime_start
+			end     = appointment_availability_or_holiday.datetime_end
+			logger.debug('Considering {} from {} to {}'.format('Extra Availability' if appointment_availability_or_holiday.kind == AVAILABILITY_EXTRA else 'Holiday', start, end))
+			portion = self.availability[pd.date_range(start=start, end=end, freq=self.minimum_slot)] #select the specific range
+			set_to	= 1 if appointment_availability_or_holiday.kind == AVAILABILITY_EXTRA else 0
+		elif isinstance(appointment_availability_or_holiday, Appointment):
+			start   = appointment_availability_or_holiday.datetime_when
+			end     = start + datetime.timedelta(minutes=appointment_availability_or_holiday.length)
+			logger.debug('Considering General Appointment from {} to {}'.format(start, end))
+			portion = self.availability[pd.date_range(start=start, end=end, freq=self.minimum_slot)] #select the specific range
+			set_to  = 0
+		elif isinstance(appointment_availability_or_holiday, AppointmentTypeLink):
+			start   = appointment_availability_or_holiday.date_when
+			end     = start + datetime.timedelta(minutes=appointment_availability_or_holiday.appointment_type.default_duration)
+			logger.debug('Considering Subject Appointment from {} to {}'.format(start, end))
+			portion = self.availability[pd.date_range(start=start, end=end, freq=self.minimum_slot)] #select the specific range
+			set_to  = 0
+		else:
+			logger.error('Expected Holiday or Availability objects.')
+			raise TypeError
+
+		if only_working_hours:
+			portion = portion.between_time(self.office_start, self.office_end)
+
+		#limit portion to be changed to the bounds of the object time space (solution 1 of the aforementioned problem)
+		portion = portion[(self.availability.index.min() <= portion.index) & (portion.index <= self.availability.index.max())]
+
+		self.availability[portion.index] = set_to
+
+	def get_availability_percentage(self, only_working_hours=False):
+		'''
+		For multiple values this is the solution: return self.availability.value_counts().div(len(s))[1] * 100 
+		But since it's 0 or 1, this works as well and is faster: return self.availability.mean() * 100
+
+		To test it:
+		import pandas as pd
+		range = pd.date_range(start='2018-10-1', end='2018-10-2 01:00', freq='5T', closed=None)
+		s = pd.Series(index=range, data=0)
+		range2 = pd.date_range(start='2018-10-1 1:00', end='2018-10-1 2:30', freq='5T')
+		s[range2] = 1
+		print(s.value_counts().div(len(s))[1]*100)   # prints 6.312292358803987
+		print(s.mean()*100)							 # prints 6.312292358803987
+		%timeit s.value_counts().div(len(s))[1]*100  # 504 µs ± 19.2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+		%timeit s.mean()*100                         # 56.3 µs ± 1.66 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
+		'''
+		if only_working_hours:
+			availability = self.availability.between_time(self.office_start, self.office_end)
+		else:
+			availability = self.availability
+
+		return availability.mean() * 100 #better to isolate the operation in case we change it later
+
+	def is_availabile(self, only_working_hours=False):
+		'''
+		Returns True if on the selected period is available at least 50% of the time
+		Otherwise returns False
+		'''
+		return self.get_availability_percentage(only_working_hours=only_working_hours) > 50.0
+
+	@timeit
+	def plot_availability(self):
+		fig = plt.figure() #create new figure. This should ensure thread safe method
+		ax=fig.gca() #get current axes
+		matplotlib.rcParams['hatch.linewidth'] = 1
+		logger.warn('business_hours: {} {}'.format(self.office_start, self.office_end))
+		business_hours = self.business_hours = pd.Series(index=self.range, data=0)
+		mask = business_hours.between_time(self.office_start, self.office_end).index
+		business_hours[mask] = 1
+		ax = business_hours.plot(kind='area', alpha = 0.33, color='#1190D8', label='Business Hours', legend=True, ax=ax)
+
+		#calculate good xticks
+		hours = self._get_duration().total_seconds()/3600
+		n_ticks = int(hours/24)
+		if n_ticks == 0:
+			minutes = self._get_duration().total_seconds()/60
+			n_ticks = int(minutes/60)
+			if n_ticks == 0:
+				n_ticks = 1
+			xticks=self.availability.asfreq('{}T'.format(n_ticks)).index
+		else:
+			xticks=self.availability.asfreq('{}H'.format(n_ticks)).index
+
+		title = 'Availability for {} from {} to {}'.format(self.name, self.start.strftime('%Y/%m/%d %H:%M'), self.end.strftime('%Y/%m/%d %H:%M'))
+
+		ax = self.availability.plot(figsize=(16, 8), grid = True, 
+			title=title, legend=True, label='Availability', color='#00af52',
+			xticks=xticks, ax=ax, yticks=[0,1])
+		
+		ax.fill_between(self.availability.index, self.availability.tolist(), facecolor="none", hatch='//', edgecolor="#00af52", alpha=1, linewidth=0.5)
+		ax.set_axisbelow(True)
+		ax.yaxis.grid(color='gray', linewidth=0.5, alpha=0)
+		ax.xaxis.grid(color='gray', linewidth=0.5, alpha=1)
+		ax.set_yticklabels(['False', 'True'])
+		ax.set_ylabel('Is Available ?')
+		ax.set_xlabel('Date & Time')
+
+		fig.tight_layout()
+		fig.savefig('{}_{}_{}.pdf'.format(self.name, self.start.strftime('%Y%m%d%H%M'), self.end.strftime('%Y%m%d%H%M')))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

smash/web/static/js/daily_planning.js

@@ -368,7 +368,21 @@ $(document).ready(function () {
         droppable: true,
         resourceAreaWidth: '15%',
         resourceLabelText: 'Workers',
-        resources: resources_url,
+        refetchResourcesOnNavigate: true,
+        resourceOrder: '-availability',
+        resources: function(callback){
+                        setTimeout(function(){
+                            var view = $('#calendar').fullCalendar('getView');
+                            $.ajax({
+                                url: resources_url,
+                                type: 'GET',
+                                cache: false,
+                                data: {
+                                    start_date: view.start.format('YYYY-MM-DD'),
+                                    }
+                                }).then(function(resources){callback(resources)});                  
+                        }, 0);
+        },
         events: [],
         eventRender: function (event, element) {
             if (event.rendering !== 'background') {