projects.py

"""
Projects service
"""
import datetime
import logging
from datetime import timedelta
from typing import List

from flask_sqlalchemy import BaseQuery

from portal import storage
from portal.async_celery import tasks
from portal.database.models import ClientType, Course, Project, ProjectConfig, ProjectState, \
    Submission, SubmissionState, User
from portal.service import errors, filters
from portal.service.errors import ForbiddenError
from portal.service.general import GeneralService, get_new_name
from portal.tools import time

log = logging.getLogger(__name__)


class ProjectService(GeneralService):
    @property
    def storage(self):
        return storage

    @property
    def _entity_klass(self):
        return Project

    def _set_data(self, entity, **data):
        allowed = ['name', 'description', 'codename', 'assignment_url']
        return self.update_entity(entity, data, allowed=allowed)

    @property
    def project(self) -> Project:
        return self._entity

    def copy_project(self, target: Course) -> Project:
        """Copies a project to the target course

        Args:
            target(Course): Course instance

        Returns(Project): Copied project
        """

        new_name = get_new_name(self.project, target)
        new_project = Project(target, codename=new_name)
        new_project.description = self.project.description
        new_project.name = self.project.name
        new_project.set_config(**vars(self.project.config))
        log.info(f"[COPY] Project from {self.project.log_name} by"
                 f" {self.client_name}: {new_project.log_name}")
        return new_project

    def can_create_submission(self, user: User) -> bool:
        """Checks if a user may create a new submission.

        A user is permitted to create a new submission if there are no submissions
        created or queued for him in the given project.

        Args:
            user(User): the user who wants to crete a new submission

        Returns: whether the user can create a new submission in the project

        """
        conflicting_states = [SubmissionState.CREATED,
                              SubmissionState.READY, SubmissionState.QUEUED]
        conflict = Submission.query.filter(Submission.user == user) \
            .filter(Submission.project == self.project) \
            .filter(Submission.state.in_(conflicting_states)) \
            .first()

        return conflict is None

    def create(self, course: Course, **data) -> Project:
        """Creates a new project

        Args:
            course(Course): Course instance
            data(dict): Project data

        Returns(Project): Project instance
        """
        new_project = Project(course=course)
        self._entity = new_project
        self._set_data(new_project, **data)
        log.info(f"[CREATE] Project  {new_project.log_name} "
                 f"by {self.client_name}: {new_project}")
        return new_project

    def update_project_config(self, data: dict) -> ProjectConfig:
        """Updates project config

        Args:
            data(dict): Config data

        Returns(ProjectConfig): Project config instance
        """
        self.project.set_config(**data)
        self.write_entity(self.project)
        log.info(f"[UPDATE] Configuration for project {self.project.log_name} "
                 f"by {self.client_name} in {data}.")
        return self.project.config

    def query_submissions(self, user: User) -> BaseQuery:
        """Queries submissions for the project and filters them by user.

        Args:
            user(User): User instance
        """
        course = self.project.course
        return Submission.query.filter(Submission.user_id == user.id) \
            .filter(Submission.project_id == self.project.id) \
            .join(Course, Course.id == self.project.course_id).filter(Course.id == course.id)

    def find_project_submissions(self, user_id: str = None) -> List[Submission]:
        """Finds all project submissions. If a user id is specified, returns only submissions created
        by that user.

        Args:
            user_id(str): User id (optional)

        Returns(List[Submission]): A list of all submissions in a project if no user_id is specified
        Otherwise a list of submissions created in the project by the specified user.

        """
        submissions = self.project.submissions
        if user_id:
            user = self.find.user(user_id)
            submissions = self.query_submissions(user)
        return submissions

    def check_submission_create(self, client=None):
        client = client or self.client
        if client.type != ClientType.USER:
            raise errors.SubmissionRefusedError(f"Worker cannot create submission.")
        user = self.find.user(client.id)
        # TODO: Might be good to add check whether it is in DEBUG Mode
        if user.is_admin:
            return True
        if self.project.state(timestamp=time.current_time()) != ProjectState.ACTIVE:
            raise errors.SubmissionRefusedError(f"Project {self.project.log_name} not active.")
        if not ProjectService(self.project).can_create_submission(client):
            raise errors.SubmissionRefusedError(
                f"Submission in project {self.project.log_name} already active.")
        self._check_latest_submission(user)
        return True

    def _check_latest_submission(self, user: User):
        latest_submission = self.get_latest_submission(user, ignore_cancel=True)
        if not latest_submission:
            return True
        latest_time = latest_submission.created_at
        now_time = datetime.datetime.utcnow()
        diff_time = now_time - latest_time
        delta = timedelta(minutes=30)  # TODO this should be configurable @mdujava
        log.info(f"Submission for project {self.project.log_name} by user {user.log_name},"
                 f" time delta: {diff_time} < {delta} = {diff_time < delta} created by"
                 f" {self.client_name}")
        if diff_time < delta:
            log.debug(f"Submission for {self.project.log_name} by {user.log_name} "
                      f"created by {self.client_name} "
                      f"rejected based on the time delta: {diff_time}")
            raise errors.SubmissionDiffTimeError(self.project, diff_time, user=user)
        return True

    def get_latest_submission(self, user, ignore_cancel: bool = False) -> Submission:
        query = Submission.query.filter(
            (Submission.user == user) & (Submission.project == self.project))
        if ignore_cancel:
            query = query.filter((Submission.state != SubmissionState.CANCELLED) &
                                 (SubmissionState != SubmissionState.ABORTED))
        return query.order_by(Submission.created_at.desc()).first()

    def find_all(self, course: Course) -> list:
        """List of all projects
        Args:
            course(Course): Course instance
        Returns(list): list of projects
        """
        perm_service = self._rest_service.permissions(course=course)
        if perm_service.check.permissions(['view_course_full']):
            return course.projects
        elif perm_service.check.permissions(['view_course_limited']):
            return filters.filter_projects_from_course(course=course, user=perm_service.client)
        raise ForbiddenError(perm_service.client)

    def update_project_test_files(self):
        """ Sends a request to Storage to update the project's test_files to the newest version.
        """
        log.info(f"[SERVICE] Updating project files for {self.project.log_name}")
        tasks.update_project_test_files.delay(self.project.course.id, self.project.id)

    def calculate_wait_time(self, user: User) -> datetime.datetime:
        latest_submission = self.get_latest_submission(user, ignore_cancel=True)
        if not latest_submission:
            return time.current_time()
        latest_time = latest_submission.created_at
        delta = datetime.timedelta(minutes=30)
        return latest_time + delta