models.py

from __future__ import unicode_literals

import json
import uuid as uuid

from django.core.exceptions import ValidationError
from django.core.validators import RegexValidator, MinValueValidator
from django.db import models
from django.db.models import Avg
from django.utils import timezone
from multiselectfield import MultiSelectField

from app import utils, hackathon_variables
from user.models import User, BlacklistUser
from user import models as userModels
from applications.validators import validate_file_extension

APP_PENDING = 'P'
APP_REJECTED = 'R'
APP_INVITED = 'I'
APP_LAST_REMIDER = 'LR'
APP_CONFIRMED = 'C'
APP_CANCELLED = 'X'
APP_ATTENDED = 'A'
APP_EXPIRED = 'E'
APP_DUBIOUS = 'D'
APP_INVALID = 'IV'
APP_BLACKLISTED = 'BL'

PENDING_TEXT = 'Under review'
DUBIOUS_TEXT = 'Dubious'
BLACKLIST_TEXT = 'Blacklisted'
STATUS = [
    (APP_PENDING, PENDING_TEXT),
    (APP_REJECTED, 'Wait listed'),
    (APP_INVITED, 'Invited'),
    (APP_LAST_REMIDER, 'Last reminder'),
    (APP_CONFIRMED, 'Confirmed'),
    (APP_CANCELLED, 'Cancelled'),
    (APP_ATTENDED, 'Attended'),
#    (APP_EXPIRED, 'Expired'),
#    (APP_DUBIOUS, DUBIOUS_TEXT),
#    (APP_INVALID, 'Invalid'),
#    (APP_BLACKLISTED, BLACKLIST_TEXT)
]

NO_ANSWER = 'NA'
MALE = 'M'
FEMALE = 'F'
NON_BINARY = 'NB'
GENDER_OTHER = 'X'

GENDERS = [
    (NO_ANSWER, 'Prefer not to answer'),
    (MALE, 'Male'),
    (FEMALE, 'Female'),
    (NON_BINARY, 'Non-binary'),
    (GENDER_OTHER, 'Prefer to self-describe'),
]

D_NONE = 'None'
D_VEGETERIAN = 'Vegeterian'
D_VEGAN = 'Vegan'
D_NO_PORK = 'No pork'
D_GLUTEN_FREE = 'Gluten-free'
D_OTHER = 'Others'

DIETS = [
    (D_NONE, 'No requirements'),
    (D_VEGETERIAN, 'Vegeterian'),
    (D_VEGAN, 'Vegan'),
    (D_NO_PORK, 'No pork'),
    (D_GLUTEN_FREE, 'Gluten-free'),
    (D_OTHER, 'Others')
]

W_XXS = 'W-XSS'
W_XS = 'W-XS'
W_S = 'W-S'
W_M = 'W-M'
W_L = 'W-L'
W_XL = 'W-XL'
W_XXL = 'W-XXL'
T_XXS = 'XXS'
T_XS = 'XS'
T_S = 'S'
T_M = 'M'
T_L = 'L'
T_XL = 'XL'
T_XXL = 'XXL'
TSHIRT_SIZES = [
    (W_XXS, "Women's - XXS"),
    (W_XS, "Women's - XS"),
    (W_S, "Women's - S"),
    (W_M, "Women's - M"),
    (W_L, "Women's - L"),
    (W_XL, "Women's - XL"),
    (W_XXL, "Women's - XXL"),
    (T_XXS, "Unisex - XXS"),
    (T_XS, "Unisex - XS"),
    (T_S, "Unisex - S"),
    (T_M, "Unisex - M"),
    (T_L, "Unisex - L"),
    (T_XL, "Unisex - XL"),
    (T_XXL, "Unisex - XXL"),
]
DEFAULT_TSHIRT_SIZE = T_M

ATTENDANCE = [
    (0, "Friday"),
    (1, "Saturday"),
    (2, "Sunday")
]
HACK_NAME = getattr(hackathon_variables, 'HACKATHON_NAME', "HackAssistant")
EXTRA_NAME = [' 2016', ' 2017', ' 2018', ' 2019']
PREVIOUS_HACKS = [(i, HACK_NAME + EXTRA_NAME[i]) for i in range(0, len(EXTRA_NAME))]

YEARS = [(int(size), size) for size in ('2018 2019 2020 2021 2022 2023 2024'.split(' '))]
DEFAULT_YEAR = 2023

ENGLISH_LEVEL = [(i, str(i)) for i in range(1, 5 + 1)]


class BaseApplication(models.Model):

    class Meta:
        abstract = True

    uuid = models.UUIDField(default=uuid.uuid4, editable=False)
    user = models.OneToOneField(User, related_name='%(class)s_application', primary_key=True, on_delete=models.CASCADE)
    invited_by = models.ForeignKey(User, related_name='%(class)s_invited_applications', blank=True, null=True,
                                   on_delete=models.SET_NULL)

    # When was the application submitted
    submission_date = models.DateTimeField(default=timezone.now)

    # When was the last status update
    status_update_date = models.DateTimeField(blank=True, null=True)

    # Application status
    status = models.CharField(choices=STATUS,
                              default=APP_PENDING,
                              max_length=2)

    # ABOUT YOU
    # Population analysis, optional
    gender = models.CharField(max_length=23, choices=GENDERS, default=NO_ANSWER)
    other_gender = models.CharField(max_length=50, blank=True, null=True)

    # Personal data (asking here because we don't want to ask birthday)
    under_age = models.BooleanField()

    phone_number = models.CharField(blank=True, null=True, max_length=16,
                                    validators=[RegexValidator(regex=r'^\+?1?\d{9,15}$',
                                                               message="Phone number must be entered in the format: \
                                                                      '+#########'. Up to 15 digits allowed.")])

    # Info for swag and food
    diet = models.CharField(max_length=300, choices=DIETS, default=D_NONE)
    other_diet = models.CharField(max_length=600, blank=True, null=True)
    tshirt_size = models.CharField(max_length=5, default=DEFAULT_TSHIRT_SIZE, choices=TSHIRT_SIZES)

    def __init__(self, *args, **kwargs):
        super(BaseApplication, self).__init__(*args, **kwargs)
        try:
            dict = args[0]['dict']
        except Exception:
            dict = None
        if dict is not None:
            for key in dict:
                atr = getattr(self, key, 'NOT_EXIST')
                if atr != 'NOT_EXIST':
                    setattr(self, key, dict[key])

    def __str__(self):
        return self.user.email

    @property
    def uuid_str(self):
        return str(self.uuid)

    def get_soft_status_display(self):
        text = self.get_status_display()
        if DUBIOUS_TEXT == text or BLACKLIST_TEXT == text:
            return PENDING_TEXT
        return text

    def save(self, **kwargs):
        self.status_update_date = timezone.now()
        super(BaseApplication, self).save(**kwargs)

    def is_confirmed(self):
        return self.status == APP_CONFIRMED

    def is_cancelled(self):
        return self.status == APP_CANCELLED

    def answered_invite(self):
        return self.status in [APP_CONFIRMED, APP_CANCELLED, APP_ATTENDED]

    def needs_action(self):
        return self.status == APP_INVITED

    def is_pending(self):
        return self.status == APP_PENDING

    def can_be_edit(self):
        return self.status == APP_PENDING

    def is_invited(self):
        return self.status == APP_INVITED

    def is_expired(self):
        return self.status == APP_EXPIRED

    def is_rejected(self):
        return self.status == APP_REJECTED

    def is_invalid(self):
        return self.status == APP_INVALID

    def is_attended(self):
        return self.status == APP_ATTENDED

    def is_last_reminder(self):
        return self.status == APP_LAST_REMIDER

    def is_dubious(self):
        return self.status == APP_DUBIOUS

    def can_be_cancelled(self):
        return self.status == APP_CONFIRMED or self.status == APP_INVITED or self.status == APP_LAST_REMIDER

    def can_confirm(self):
        return self.status in [APP_INVITED, APP_LAST_REMIDER]

    def can_be_invited(self):
        return self.status in [APP_INVITED, APP_LAST_REMIDER, APP_CANCELLED, APP_PENDING, APP_EXPIRED, APP_REJECTED,
                               APP_INVALID]

    def can_join_team(self):
        return self.user.type == userModels.USR_HACKER and self.status in [APP_PENDING, APP_LAST_REMIDER, APP_DUBIOUS]

    def check_in(self):
        self.status = APP_ATTENDED
        self.status_update_date = timezone.now()
        self.save()

    def move_to_pending(self):
        self.status = APP_PENDING
        self.status_update_date = timezone.now()
        self.save()

    def reject(self):
        if self.status == APP_ATTENDED:
            raise ValidationError('Application has already attended. '
                                  'Current status: %s' % self.status)
        self.status = APP_REJECTED
        self.status_update_date = timezone.now()
        self.save()

    def invite(self, user):
        # We can re-invite someone invited
        if self.status in [APP_CONFIRMED, APP_ATTENDED]:
            raise ValidationError('Application has already answered invite. '
                                  'Current status: %s' % self.status)
        self.status = APP_INVITED
        if not self.invited_by:
            self.invited_by = user
        self.last_invite = timezone.now()
        self.last_reminder = None
        self.status_update_date = timezone.now()
        self.save()

    def confirm(self):
        if self.status == APP_CANCELLED:
            raise ValidationError('This invite has been cancelled.')
        elif self.status == APP_EXPIRED:
            raise ValidationError('Unfortunately your invite has expired.')
        elif self.status in [APP_INVITED, APP_LAST_REMIDER]:
            self.status = APP_CONFIRMED
            self.status_update_date = timezone.now()
            self.save()
        elif self.status in [APP_CONFIRMED, APP_ATTENDED]:
            return None
        else:
            raise ValidationError('Unfortunately his application hasn\'t been '
                                  'invited [yet]')

    def cancel(self):
        if not self.can_be_cancelled():
            raise ValidationError('Application can\'t be cancelled. Current '
                                  'status: %s' % self.status)
        if self.status != APP_CANCELLED:
            self.status = APP_CANCELLED
            self.status_update_date = timezone.now()
            self.save()
            reimb = getattr(self.user, 'reimbursement', None)
            if reimb:
                reimb.delete()

    def last_reminder(self):
        if self.status != APP_INVITED:
            raise ValidationError('Reminder can\'t be sent to non-pending '
                                  'applications')
        self.status_update_date = timezone.now()
        self.status = APP_LAST_REMIDER
        self.save()

    def expire(self):
        self.status_update_date = timezone.now()
        self.status = APP_EXPIRED
        self.save()


class _HackerMentorVolunteerApplication(models.Model):

    class Meta:
        abstract = True

    # Where is this person coming from?
    origin = models.CharField(max_length=300)

    # Is this your first hackathon?
    first_timer = models.BooleanField(default=False)

    # Random lenny face
    # lennyface = models.CharField(max_length=300, default='-.-')

    # University
    graduation_year = models.IntegerField(choices=YEARS, default=DEFAULT_YEAR)
    university = models.CharField(max_length=300)
    degree = models.CharField(max_length=300)


class _HackerMentorApplication(models.Model):

    class Meta:
        abstract = True

    # URLs
    github = models.URLField(blank=True, null=True)
    devpost = models.URLField(blank=True, null=True)
    linkedin = models.URLField(blank=True, null=True)
    site = models.URLField(blank=True, null=True)

    # Giv me a resume here!
    # resume = models.FileField(upload_to='resumes', null=True, blank=True, validators=[validate_file_extension])


class _VolunteerMentorApplication(models.Model):

    class Meta:
        abstract = True

    english_level = models.IntegerField(default=0, null=False, choices=ENGLISH_LEVEL)
    which_hack = MultiSelectField(choices=PREVIOUS_HACKS, null=True, blank=True)


class _VolunteerMentorSponsorApplication(models.Model):

    class Meta:
        abstract = True

    attendance = MultiSelectField(choices=ATTENDANCE)


class HackerApplication(
    BaseApplication,
    _HackerMentorVolunteerApplication,
    _HackerMentorApplication
):
    # Explain a little bit what projects have you done lately
    projects = models.TextField(max_length=500, blank=True, null=True)

    # META
    contacted = models.BooleanField(default=False)  # If a dubious application has been contacted yet
    contacted_by = models.ForeignKey(User, related_name='contacted_by', blank=True, null=True,
                                     on_delete=models.SET_NULL)

    reviewed = models.BooleanField(default=False)  # If a blacklisted application has been reviewed yet
    blacklisted_by = models.ForeignKey(User, related_name='blacklisted_by', blank=True, null=True,
                                       on_delete=models.SET_NULL)

    # Why do you want to come to X?
    # description = models.TextField(max_length=500)

    # Questions
    question_1 = models.TextField(max_length=500, blank=True, null=True)
    question_2 = models.TextField(max_length=500, blank=True, null=True)
    question_3 = models.TextField(max_length=500, blank=True, null=True)

    # Reimbursement
    reimb = models.BooleanField(default=False)
    reimb_amount = models.FloatField(blank=True, null=True, validators=[
        MinValueValidator(0, "Negative? Really? Please put a positive value")])

    @classmethod
    def annotate_vote(cls, qs):
        return qs.annotate(vote_avg=Avg('vote__calculated_vote'))

    def invalidate(self):
        if self.status != APP_DUBIOUS:
            raise ValidationError('Applications can only be marked as invalid if they are dubious first')
        self.status = APP_INVALID
        self.save()

    def set_dubious(self):
        self.status = APP_DUBIOUS
        self.contacted = False
        self.status_update_date = timezone.now()
        self.save()

    def unset_dubious(self):
        self.status = APP_PENDING
        self.status_update_date = timezone.now()
        self.save()

    def set_contacted(self, user):
        if not self.contacted:
            self.contacted = True
            self.contacted_by = user
            self.save()

    def confirm_blacklist(self, user, motive_of_ban):
        if self.status != APP_BLACKLISTED:
            raise ValidationError('Applications can only be confirmed as blacklisted if they are blacklisted first')
        self.status = APP_INVALID
        self.set_blacklisted_by(user)
        blacklist_user = BlacklistUser.objects.filter(email=self.user.email).first()
        if not blacklist_user:
            blacklist_user = BlacklistUser.objects.create_blacklist_user(
                self.user, motive_of_ban)
        blacklist_user.save()
        self.save()

    def set_blacklist(self):
        self.status = APP_BLACKLISTED
        self.status_update_date = timezone.now()
        self.save()

    def unset_blacklist(self):
        self.status = APP_PENDING
        self.status_update_date = timezone.now()
        self.save()

    def set_blacklisted_by(self, user):
        if not self.blacklisted_by:
            self.blacklisted_by = user

    def is_blacklisted(self):
        return self.status == APP_BLACKLISTED

    def can_be_edit(self):
        return self.status == APP_PENDING and not self.vote_set.exists() and not utils.is_app_closed()


class MentorApplication(
    BaseApplication,
    _HackerMentorApplication,
    _HackerMentorVolunteerApplication,
    _VolunteerMentorApplication,
    _VolunteerMentorSponsorApplication
):
    company = models.CharField(max_length=100, null=True, blank=True)
    why_mentor = models.CharField(max_length=500, null=False)
    first_time_mentor = models.BooleanField(null=False)
    fluent = models.CharField(max_length=150, null=False)
    experience = models.CharField(max_length=300, null=False)
    study_work = models.BooleanField(max_length=300, null=False)
    university = models.CharField(max_length=300, null=True, blank=True)
    degree = models.CharField(max_length=300, null=True, blank=True)
    participated = models.TextField(max_length=500, blank=True, null=True)


class VolunteerApplication(
    BaseApplication,
    _VolunteerMentorSponsorApplication,
    _VolunteerMentorApplication,
    _HackerMentorVolunteerApplication
):
    cool_skill = models.CharField(max_length=100, null=False)
    first_time_volunteer = models.BooleanField(null=False)
    quality = models.CharField(max_length=150, null=False)
    weakness = models.CharField(max_length=150, null=False)
    fav_movie = models.CharField(max_length=60, null=True, blank=True)
    friends = models.CharField(max_length=100, null=True, blank=True)


class SponsorApplication(
    _VolunteerMentorSponsorApplication,
):
    name = models.CharField(
        verbose_name='Full name',
        max_length=255,
    )
    # When was the application submitted
    submission_date = models.DateTimeField(default=timezone.now)

    # When was the last status update
    status_update_date = models.DateTimeField(blank=True, null=True)
    uuid = models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True)
    user = models.ForeignKey(User, related_name='%(class)s_application', null=True, on_delete=models.SET_NULL)
    # Application status
    status = models.CharField(choices=STATUS,
                              default=APP_CONFIRMED,
                              max_length=2)
    phone_number = models.CharField(blank=True, null=True, max_length=16,
                                    validators=[RegexValidator(regex=r'^\+?1?\d{9,15}$',
                                                               message="Phone number must be entered in the format: \
                                                                          '+#########'. Up to 15 digits allowed.")])

    # Info for swag and food
    diet = models.CharField(max_length=300, choices=DIETS, default=D_NONE)
    other_diet = models.CharField(max_length=600, blank=True, null=True)
    tshirt_size = models.CharField(max_length=5, default=DEFAULT_TSHIRT_SIZE, choices=TSHIRT_SIZES)
    position = models.CharField(max_length=50, null=False)

    @property
    def uuid_str(self):
        return str(self.uuid)

    def __str__(self):
        return self.name + ' from ' + self.user.name

    def save(self, **kwargs):
        self.status_update_date = timezone.now()
        super(SponsorApplication, self).save(**kwargs)

    def check_in(self):
        self.status = APP_ATTENDED
        self.status_update_date = timezone.now()
        self.save()

    class META:
        unique_together = [['name', 'user']]


class DraftApplication(models.Model):
    content = models.CharField(max_length=7000)
    user = models.OneToOneField(User, primary_key=True, on_delete=models.CASCADE)

    def save_dict(self, d):
        self.content = json.dumps(d)

    def get_dict(self):
        return json.loads(self.content)