worker.py

# coding=utf-8
import datetime
import logging

from django.contrib.auth.models import User, AnonymousUser
from django.db import models

from web.models.constants import GLOBAL_STUDY_ID, COUNTRY_OTHER_ID
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

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
                                       )
    appointments = models.ManyToManyField('web.Appointment', blank=True,
                                          verbose_name='Appointments'
                                          )
    user = models.OneToOneField(User, blank=True, null=True,
                                verbose_name='Username'
                                )
    first_name = models.CharField(max_length=50,
                                  verbose_name='First name'
                                  )
    last_name = models.CharField(max_length=50,
                                 verbose_name='Last name'
                                 )
    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'
    )

    specialization = models.CharField(max_length=20,
                                      verbose_name='Specialization',
                                      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())):
            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

    @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))

    @staticmethod
    def get_details(the_user):
        persons = Worker.objects.filter(user=the_user)

        if len(persons) == 0:
            return the_user.get_full_name(), '<No worker information>'
        else:
            person = persons[0]
            role = "N/A"
            if person.roles.filter(study=GLOBAL_STUDY_ID).count() > 0:
                role = person.roles.filter(study=GLOBAL_STUDY_ID)[0].get_role_display()
            return unicode(person), role

    def __str__(self):
        return "%s %s" % (self.first_name, self.last_name)

    def __unicode__(self):
        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