# coding=utf-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
from web.models.constants import GLOBAL_STUDY_ID, COUNTRY_OTHER_ID, AVAILABILITY_HOLIDAY, AVAILABILITY_EXTRA
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__)
def roles_by_worker_type(worker_type):
role_choices = role_choices_by_worker_type(worker_type)
roles = []
for role_type, role_name in role_choices:
roles.append(role_type)
return roles
def role_choices_by_worker_type(worker_type):
if worker_type == WORKER_STAFF:
return STUDY_ROLE_CHOICES
elif worker_type == WORKER_HEALTH_PARTNER:
return HEALTH_PARTNER_ROLE_CHOICES
elif worker_type == WORKER_VOUCHER_PARTNER:
return VOUCHER_PARTNER_ROLE_CHOICES
else:
raise TypeError("Unknown worker type")
def worker_type_by_worker(worker):
roles = worker.roles.filter(study=GLOBAL_STUDY_ID)
if roles.count() == 0:
return WORKER_STAFF
role = roles[0].role
for role_type, role_name in STUDY_ROLE_CHOICES:
if role_type == role:
return WORKER_STAFF
for role_type, role_name in HEALTH_PARTNER_ROLE_CHOICES:
if role_type == role:
return WORKER_HEALTH_PARTNER
for role_type, role_name in VOUCHER_PARTNER_ROLE_CHOICES:
if role_type == role:
return WORKER_VOUCHER_PARTNER
raise TypeError("Unknown worker role")
class Worker(models.Model):
class Meta:
app_label = 'web'
languages = models.ManyToManyField("web.Language",
verbose_name='Known languages',
blank=True
)
locations = models.ManyToManyField("web.Location",
verbose_name='Locations',
blank=True
)
user = models.OneToOneField(User, blank=True, null=True,
verbose_name='Username'
)
first_name = models.CharField(max_length=50,
verbose_name='First name',
blank=True,
)
last_name = models.CharField(max_length=50,
verbose_name='Last name',
blank=True,
)
name = models.CharField(max_length=50,
verbose_name='Name',
default='',
blank=True,
null=False
)
phone_number = models.CharField(max_length=20,
verbose_name='Phone number',
blank=True
)
phone_number_2 = models.CharField(max_length=20,
verbose_name='Phone number 2',
blank=True
)
fax_number = models.CharField(max_length=20,
verbose_name='Fax number',
blank=True
)
address = models.CharField(max_length=255,
blank=True,
verbose_name='Address'
)
postal_code = models.CharField(max_length=7,
blank=True,
verbose_name='Postal code'
)
city = models.CharField(max_length=50,
blank=True,
verbose_name='City'
)
country = models.ForeignKey('web.Country',
null=False,
blank=False,
default=COUNTRY_OTHER_ID,
verbose_name='Country'
)
voucher_types = models.ManyToManyField("web.VoucherType",
verbose_name='Voucher types',
blank=True
)
unit = models.CharField(max_length=50,
verbose_name='Unit',
blank=True
)
email = models.EmailField(
verbose_name='E-mail',
blank=True
)
specialization = models.CharField(max_length=20,
verbose_name='Specialization',
blank=True
)
voucher_partner_code = models.CharField(max_length=10,
verbose_name='Code',
blank=True
)
comment = models.TextField(max_length=1024,
verbose_name='Comment',
null=True,
blank=True
)
def is_on_leave(self):
if len(self.holiday_set.filter(datetime_end__gt=datetime.datetime.now(),
datetime_start__lt=datetime.datetime.now(),
kind=AVAILABILITY_HOLIDAY)):
return True
return False
def disable(self):
if self.user is not None:
self.user.is_active = False
self.user.save()
logger.info("'" + self.user.username + "' account has been disabled")
return True
else:
logger.warn("Cannot disable account for user '" + self.first_name + " " + self.last_name + "'")
return False
def is_active(self):
if self.user is not None:
return self.user.is_active
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(u'{} {}'.format(self.first_name, self.last_name), start=start_date, end=end_date)
#Subject Appointments
old_events = Q(date_when__gt=start_date) & Q(date_when__gt=end_date)
future_events = Q(date_when__lt=start_date) & Q(date_when__lt=end_date)
non_overlap_events = old_events | future_events
overlap_events = ~non_overlap_events
query = Q(worker=self.id) & overlap_events
subject_appointments = AppointmentTypeLink.objects.filter(query)
#General Appointments
old_events = Q(datetime_when__gt=start_date) & Q(datetime_when__gt=end_date)
future_events = Q(datetime_when__lt=start_date) & Q(datetime_when__lt=end_date)
non_overlap_events = old_events | future_events
overlap_events = ~non_overlap_events
query = Q(worker_assigned=self.id) & overlap_events
general_appointments = Appointment.objects.filter(query)
#Holidays and extra availabilities.
old_events = Q(datetime_start__gt=start_date) & Q(datetime_start__gt=end_date)
future_events = Q(datetime_end__lt=start_date) & Q(datetime_end__lt=end_date)
non_overlap_events = old_events | future_events
overlap_events = ~non_overlap_events
holidays_and_extra_availabilities = self.holiday_set.filter(overlap_events).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)
if roles.count() == 0:
return WORKER_STAFF
role = roles[0].role
if role not in [role_type for role_type, _ in ROLE_CHOICES]:
raise TypeError("Unknown worker role")
return role
@staticmethod
def get_by_user(the_user):
if isinstance(the_user, User):
workers = Worker.objects.filter(user=the_user)
if len(workers) > 0:
return workers[0]
else:
return None
elif isinstance(the_user, Worker):
return the_user
elif isinstance(the_user, AnonymousUser):
return None
elif the_user is not None:
raise TypeError("Unknown class type: " + the_user.__class__.__name__)
else:
return None
@staticmethod
def get_workers_by_worker_type(worker_type, study_id=GLOBAL_STUDY_ID):
return Worker.objects.filter(roles__study_id=study_id,
roles__role__in=roles_by_worker_type(worker_type))
def __str__(self):
if self.name != '':
if self.first_name == '':
return self.name
else:
return "%s %s %s" % (self.name, self.first_name, self.last_name)
else:
return "%s %s" % (self.first_name, self.last_name)
def __unicode__(self):
if self.name != '':
if self.first_name == '':
return self.name
else:
return "%s %s %s" % (self.name, self.first_name, self.last_name)
else:
return "%s %s" % (self.first_name, self.last_name)
def initials(self):
result = ""
if len(self.first_name) > 0:
result += self.first_name[0]
if len(self.last_name) > 0:
result += self.last_name[0]
return result