patt/models.py

import datetime
from django.contrib.auth.models import User
from django.db import models
from django.utils.dateformat import format
from django.utils.translation import gettext as _
from simple_history.models import HistoricalRecords

# PROJECTSTATE (REQ-??)
#
PROJECTSTATE_OPEN = 0
PROJECTSTATE_CLOSED = 2
PROJECTS_IN_WORK = (PROJECTSTATE_OPEN, )
#
PROJECTSTATE_CHOICES = (
    (PROJECTSTATE_OPEN, _('Open')),
    (PROJECTSTATE_CLOSED, _('Closed')),
)


# TASKSTATE (REQ-14)
#
TASKSTATE_OPEN = 0
TASKSTATE_FINISHED = 1
TASKSTATE_CLOSED = 2
TASKSTATE_CANCELED = 3
TASKS_IN_WORK = (TASKSTATE_OPEN, TASKSTATE_FINISHED, )
#
TASKSTATE_CHOICES = (
    (TASKSTATE_OPEN, _('Open')),
    (TASKSTATE_FINISHED, _('Finished')),
    (TASKSTATE_CLOSED, _('Closed')),
    (TASKSTATE_CANCELED, _('Cancelled')),
)


# TASKPRIORITY (REQ-??)
#
PRIO_CHOICES = (
    (1, _('1 - Highest')),
    (2, _('2 - High')),
    (3, _('3 - Above-Average')),
    (4, _('4 - Average')),
    (5, _('5 - Below-Average')),
    (6, _('6 - Low')),
    (7, _('7 - Lowest')),
)


# TASKPROGRESS (REQ-??)
#
PRORGRESS_CHOICES = (
    (0, '0 %'),
    (10, '10 %'),
    (20, '20 %'),
    (30, '30 %'),
    (40, '40 %'),
    (50, '50 %'),
    (60, '60 %'),
    (70, '70 %'),
    (80, '80 %'),
    (90, '90 %'),
    (100, '100 %'),
)

# COMMENTTYPE (REQ-??)
#
COMMENTTYPE_COMMENT = 0
COMMENTTYPE_APPRAISAL = 1
#
COMMENTTYPE_CHOICES = (
    (COMMENTTYPE_APPRAISAL, _('Appraisal')),
    (COMMENTTYPE_COMMENT, _('Comment')),
)


# GENERAL Methods and Classes
#
class ModelList(list):
    def __init__(self, lst, chk=None, user=None):
        if chk is None:
            list.__init__(self, lst)
        else:
            list.__init__(self)
            for e in lst:
                acc = chk(e, user)
                if acc.read:
                    self.append(e)

    def sort(self, **kwargs):
        list.sort(self, key=lambda entry: entry.sort_string(), reverse=kwargs.get('reverse', False))


# PROCECT Model
#
class Project(models.Model):
    name = models.CharField(max_length=128)                                                 # REQ-7
    description = models.TextField(default='', blank=True)                                  # REQ-8
    state = models.IntegerField(choices=PROJECTSTATE_CHOICES, default=PROJECTSTATE_OPEN)    # REQ-26
    role_leader = models.ManyToManyField(User, related_name='role_leader')                  # REQ-9
    role_member = models.ManyToManyField(User, related_name='role_member', blank=True)      # REQ-12
    role_visitor = models.ManyToManyField(User, related_name='role_visitor', blank=True)    # REQ-33
    creation_date = models.DateTimeField(auto_now_add=True)
    days_late = models.IntegerField(default=0, choices=((-1, _('Off')), (0, 0), ))
    days_very_soon = models.IntegerField(default=3, choices=((-1, _('Off')), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (7, 7), (9, 9), ))
    days_soon = models.IntegerField(default=7, choices=((-1, _('Off')), (1, 1), (2, 2), (3, 3), (5, 5), (7, 7), (10, 10), (14, 14), ))

    @property
    def attachment_target_path(self):
        if self.id:
            return 'patt/project/%d' % self.id
        else:
            return 'patt/project/new'

    @property
    def formatted_leaders(self):
        if self.id:     # in preview (before saving), the ManyToManyFields are not available
            return ', '.join([user.username for user in self.role_leader.all()]) or '-'
        else:
            return '...'

    @property
    def formatted_members(self):
        if self.id:     # in preview (before saving), the ManyToManyFields are not available
            return ', '.join([user.username for user in self.role_member.all()]) or '-'
        else:
            return '...'

    @property
    def formatted_visitors(self):
        if self.id:     # in preview (before saving), the ManyToManyFields are not available
            return ', '.join([user.username for user in self.role_visitor.all()]) or '-'
        else:
            return '...'

    def sort_string(self):
        return (self.state, self.name)

    def __str__(self):
        return 'Project #%d: %s' % (self.id, self.name)


# TASK Model
#
class Task(models.Model):
    FUSION_STATE_FINISHED = 0
    FUSION_STATE_NORMAL = 1
    FUSION_STATE_SOON = 2
    FUSION_STATE_VERY_SOON = 3
    FUSION_STATE_LATE = 4
    #
    SAVE_ON_CHANGE_FIELDS = ['state', 'priority', 'targetdate', 'progress', 'name', 'description', 'assigned_user', 'project']
    #
    state = models.IntegerField(default=TASKSTATE_OPEN)                                         # REQ-14
    priority = models.IntegerField(choices=PRIO_CHOICES, default=4)                             # REQ-15
    targetdate = models.DateField(null=True, blank=True)                                        # REQ-16
    progress = models.IntegerField(default=0, choices=PRORGRESS_CHOICES)                        # REQ-17
    name = models.CharField(max_length=150, default='')                                         # REQ-?? (18)
    description = models.TextField(default='', blank=True)                                      # REQ-??
    assigned_user = models.ForeignKey(User, null=True, blank=True, on_delete=models.SET_NULL)   # REQ-31
    project = models.ForeignKey(Project, on_delete=models.CASCADE)                              # REQ-??
    creation_date = models.DateTimeField(auto_now_add=True)
    #
    history = HistoricalRecords()

    @property
    def taskname_prefix(self):
        if self.assigned_user:
            return '**#%d //(%s)//:** ' % (self.id, self.assigned_user.username)
        else:
            return '**#%d:** ' % self.id

    def save(self, force_insert=False, force_update=False, using=None, update_fields=None):
        if self.id and not force_update:
            orig = Task.objects.get(id=self.id)
            for key in self.SAVE_ON_CHANGE_FIELDS:
                if getattr(self, key) != getattr(orig, key):
                    break
            else:
                self.save_needed = False
                return False
        self.save_needed = True
        return models.Model.save(self, force_insert=force_insert, force_update=force_update, using=using, update_fields=update_fields)

    @property
    def attachment_target_path(self):
        if self.id:
            return 'patt/task/%d' % self.id
        else:
            return 'patt/task/new'

    @property
    def comments(self):
        rv = ModelList(self.comment_set.all())
        rv.sort(reverse=True)
        return rv

    def datafusion_state(self):
        if self.state in [TASKSTATE_CANCELED, TASKSTATE_CLOSED, TASKSTATE_FINISHED]:
            return self.FUSION_STATE_FINISHED
        else:
            if self.targetdate is not None:
                if type(self.targetdate) == datetime.date:
                    targetdate = self.targetdate
                else:
                    targetdate = datetime.datetime.strptime(self.targetdate, '%Y-%m-%d').date()
                if targetdate - datetime.date.today() <= datetime.timedelta(self.project.days_late) and self.project.days_late >= 0:
                    return self.FUSION_STATE_LATE
                elif targetdate - datetime.date.today() <= datetime.timedelta(self.project.days_very_soon) and self.project.days_very_soon >= 0:
                    return self.FUSION_STATE_VERY_SOON
                elif targetdate - datetime.date.today() <= datetime.timedelta(self.project.days_soon) and self.project.days_soon >= 0:
                    return self.FUSION_STATE_SOON
        return self.FUSION_STATE_NORMAL

    @property
    def class_by_state(self):
        return {
            self.FUSION_STATE_FINISHED: 'task-finished',
            self.FUSION_STATE_NORMAL: 'task-normal',
            self.FUSION_STATE_VERY_SOON: 'task-very-soon',
            self.FUSION_STATE_SOON: 'task-soon',
            self.FUSION_STATE_LATE: 'task-late',
        }.get(self.datafusion_state())

    def sort_string(self):
        if self.targetdate:
            td = int(format(self.targetdate, 'U'))
        else:
            td = 999999999999
        return (100 - self.datafusion_state(), self.state, self.priority, td, self.progress, self.name)

    def __str__(self):
        return 'Task #%d: %s' % (self.id, self.name)


# COMMENT Model
#
class Comment(models.Model):                                    # REQ-19 and REQ-20
    SAVE_ON_CHANGE_FIELDS = ['task', 'user', 'type', 'comment']
    task = models.ForeignKey(Task, on_delete=models.CASCADE)
    user = models.ForeignKey(User, null=True, blank=True, on_delete=models.SET_NULL)
    type = models.IntegerField(choices=COMMENTTYPE_CHOICES, default=COMMENTTYPE_COMMENT)
    creation_date = models.DateTimeField(auto_now_add=True)
    comment = models.TextField()
    #
    history = HistoricalRecords()

    def save(self, force_insert=False, force_update=False, using=None, update_fields=None):
        if self.id and not force_update:
            orig = Comment.objects.get(id=self.id)
            for key in self.SAVE_ON_CHANGE_FIELDS:
                if getattr(self, key) != getattr(orig, key):
                    break
            else:
                self.save_needed = False
                return False
        self.save_needed = True
        return models.Model.save(self, force_insert=force_insert, force_update=force_update, using=using, update_fields=update_fields)

    @property
    def attachment_target_path(self):
        if self.id:
            return 'patt/comment/%d' % self.id
        else:
            return 'patt/comment/new'

    @property
    def style(self):
        return {
            COMMENTTYPE_APPRAISAL: 'taskappraisal',
        }.get(self.type, 'taskcomment')

    @property
    def is_comment(self):
        return self.type == COMMENTTYPE_COMMENT

    @property
    def is_appraisal(self):
        return self.type == COMMENTTYPE_APPRAISAL

    def sort_string(self):
        return (self.creation_date, self.type, self.comment)

    def __str__(self):
        return 'Comment #%d: %s' % (self.id, self.task.name)


# SEARCH Model
#
class Search(models.Model):
    name = models.CharField(max_length=48)
    search_txt = models.TextField(default='', blank=True)
    user = models.ForeignKey(User, on_delete=models.CASCADE)