ska-referee-test/ref-test/app/models/entry.py

from ..modules import db
from ..tools.forms import JsonEncodedDict
from ..tools.encryption import decrypt, encrypt
from ..tools.logs import write
from .test import Test

from flask_login import current_user

from datetime import datetime, timedelta
from uuid import uuid4

class Entry(db.Model):

    id = db.Column(db.String(36), primary_key=True)
    first_name = db.Column(db.String(128), nullable=False)
    surname = db.Column(db.String(128), nullable=False)
    email = db.Column(db.String(128), nullable=False)
    club = db.Column(db.String(128), nullable=True)
    test_id = db.Column(db.String(36), db.ForeignKey('test.id'))
    user_code = db.Column(db.String(6), nullable=True)
    start_time = db.Column(db.DateTime, nullable=True)
    end_time = db.Column(db.DateTime, nullable=True)
    status = db.Column(db.String(16), nullable=True)
    valid = db.Column(db.Boolean, default=True, nullable=True)
    answers = db.Column(JsonEncodedDict, nullable=True)
    result = db.Column(JsonEncodedDict, nullable=True)
    
    def __repr__(self):
        return f'<New entry by {self.first_name} {self.surname}> was added with <id {self.id}>.'

    @property
    def generate_id(self): raise AttributeError('generate_id is not a readable attribute.')

    generate_id.setter
    def generate_id(self): self.id = uuid4().hex

    @property
    def set_first_name(self): raise AttributeError('set_first_name is not a readable attribute.')

    set_first_name.setter
    def set_first_name(self, name:str): self.first_name = encrypt(name)

    def get_first_name(self): return decrypt(self.first_name)

    @property
    def set_surname(self): raise AttributeError('set_first_name is not a readable attribute.')

    set_surname.setter
    def set_surname(self, name:str): self.surname = encrypt(name)

    def get_surname(self): return decrypt(self.surname)

    @property
    def set_email(self): raise AttributeError('set_email is not a readable attribute.')

    set_email.setter
    def set_email(self, email:str): self.email = encrypt(email)

    def get_email(self): return decrypt(self.email)

    @property
    def set_club(self): raise AttributeError('set_club is not a readable attribute.')

    set_club.setter
    def set_club(self, club:str): self.club = encrypt(club)

    def get_club(self): return decrypt(self.club)

    def ready(self):
        self.generate_id()
        db.session.add(self)
        db.session.commit()
        write('tests.log', f'New test ready for {self.get_first_name()} {self.get_surname()}.')
        return True, f'Test ready.'

    def start(self):
        self.start_time = datetime.now()
        self.status = 'started'
        write('tests.log', f'Test started by {self.get_first_name()} {self.get_surname()}.')
        db.session.commit()
        return True, f'New test started with id {self.id}.'

    def complete(self, answers:dict=None, result:dict=None):
        self.end_time = datetime.now()
        self.answers = answers
        self.result = result
        write('tests.log', f'Test completed by {self.get_first_name()} {self.get_surname()}.')
        delta = timedelta(minutes=self.test.time_limit+1)
        if not self.test.time_limit or self.end_time <= self.start_time + delta:
            self.status = 'completed'
            self.valid = True
        else:
            self.status = 'late'
            self.valid = False
        db.session.commit()
        return True, f'Test entry completed for id {self.id}.'

    def validate(self):
        if self.valid: return False, f'The entry is already valid.'
        if self.status == 'started': return False, 'The entry is still pending.'
        self.valid = True
        self.status = 'completed'
        db.session.commit()
        write('system.log', f'The entry {self.id} has been validated by {current_user.get_username()}.')
        return True, f'The entry {self.id} has been validated.'

    def delete(self):
        id = self.id
        name = f'{self.get_first_name()} {self.get_surname()}'
        db.session.delete(self)
        db.session.commit()
        write('system.log', f'The entry {id} by {name} has been deleted by {current_user.get_username()}.')
        return True, 'Entry deleted.'