class.ilExcAssMemberState.php

Go to the documentation of this file.

<?php

/* Copyright (c) 1998-2017 ILIAS open source, Extended GPL, see docs/LICENSE */

class ilExcAssMemberState
{
    protected $ass_id;

    protected $user_id;

    protected $assignment;

    protected $member_id;

    protected $team_id = 0;

    protected $is_team = false;

    protected function __construct(ilExAssignment $a_ass, ilObjUser $a_user, ilExcIndividualDeadline $a_idl, $a_time, ilLanguage $lng, ilExAssignmentTeam $a_team = null)
    {
        $this->time = $a_time;
        $this->ass_id = $a_ass->getId();
        $this->user_id = $a_user->getId();
        $this->member_id = $a_user->getId();
        $this->lng = $lng;

        $this->assignment = $a_ass;

        // check team status
        $this->is_team = false;
        if ($this->assignment->getType() == ilExAssignment::TYPE_UPLOAD_TEAM) {
            if ($a_team->getId()) {
                $this->member_id = $a_team->getId();
                $this->team_id = $a_team->getId();
                $this->is_team = true;
            }
        }

        $this->idl = $a_idl;
    }

    public static function getInstanceByIds($a_ass_id, $a_user_id = 0)
    {
        global $DIC;

        $lng = $DIC->language();
        $user = ($a_user_id > 0)
            ? new ilObjUser($a_user_id)
            : $DIC->user();

        $ass = new ilExAssignment($a_ass_id);

        $member_id = $user->getId();
        $is_team = false;
        $team = null;
        if ($ass->getType() == ilExAssignment::TYPE_UPLOAD_TEAM) {              // better move this to ilExcIndividualDeadline
            $team = ilExAssignmentTeam::getInstanceByUserId($a_ass_id, $user->getId());
            if ($team->getId()) {
                $member_id = $team->getId();
                $is_team = true;
            }
        }

        // note: team may be not null, but is_team still false
        $idl = ilExcIndividualDeadline::getInstance($a_ass_id, $member_id, $is_team);

        return self::getInstance($ass, $user, $idl, time(), $lng, $team);
    }

    public static function getInstance(ilExAssignment $a_ass, ilObjUser $a_user, ilExcIndividualDeadline $a_idl, $a_time, ilLanguage $lng, ilExAssignmentTeam $a_team = null)
    {
        return new self($a_ass, $a_user, $a_idl, $a_time, $lng, $a_team);
    }

    public function getIndividualDeadlineObject()
    {
        return $this->idl;
    }
    
    
    public function getGeneralStart()
    {
        return $this->assignment->getStartTime();
    }

    public function getGeneralStartPresentation()
    {
        if ($this->getGeneralStart()) {
            return $this->getTimePresentation($this->getGeneralStart());
        }
        return "";
    }

    public function getIndividualStart()
    {
        if ($this->assignment->getDeadlineMode() == ilExAssignment::DEADLINE_RELATIVE) {
            return $this->idl->getStartingTimestamp();
        }
        return 0;
    }


    public function hasGenerallyStarted()
    {
        return !$this->assignment->notStartedYet();
    }

    public function getCalculatedDeadline()
    {
        $calculated_deadline = 0;
        if ($this->assignment->getDeadlineMode() == ilExAssignment::DEADLINE_RELATIVE) {
            if ($this->idl->getStartingTimestamp() && $this->assignment->getRelativeDeadline()) {
                $calculated_deadline = $this->idl->getStartingTimestamp() + ($this->assignment->getRelativeDeadline() * 24 * 60 * 60);
            }
            if ($this->assignment->getRelDeadlineLastSubmission() > 0 &&
                $calculated_deadline > $this->assignment->getRelDeadlineLastSubmission()) {
                $calculated_deadline = $this->assignment->getRelDeadlineLastSubmission();
            }
        }
        return $calculated_deadline;
    }

    public function getRelativeDeadline()
    {
        if ($this->assignment->getDeadlineMode() == ilExAssignment::DEADLINE_RELATIVE) {
            return $this->assignment->getRelativeDeadline();
        }
        return 0;
    }

    public function getLastSubmissionOfRelativeDeadline()
    {
        if ($this->assignment->getDeadlineMode() == ilExAssignment::DEADLINE_RELATIVE) {
            return $this->assignment->getRelDeadlineLastSubmission();
        }
        return 0;
    }


    public function getRelativeDeadlinePresentation()
    {
        if ($this->assignment->getDeadlineMode() == ilExAssignment::DEADLINE_RELATIVE) {
            return $this->getRelativeDeadline() . " " . $this->lng->txt("days");
        }
        return "";
    }

    public function getOfficialDeadline()
    {
        $dl = $this->idl->getIndividualDeadline();              // team or user individual deadline

        if ($this->assignment->getDeadlineMode() == ilExAssignment::DEADLINE_ABSOLUTE) {        // absolute deadline
            return max($this->assignment->getDeadline(), $dl);                          // take what's greater: idl or abs deadline
        }

        // relative deadline: take max idl or calculated deadline
        return max($this->getCalculatedDeadline(), $dl);
    }


    public function getOfficialDeadlinePresentation()
    {
        if ($this->getOfficialDeadline() > 0) {
            return $this->getTimePresentation($this->getOfficialDeadline());
        }

        return "";
    }

    public function getLastSubmissionOfRelativeDeadlinePresentation()
    {
        if ($this->getLastSubmissionOfRelativeDeadline() > 0) {
            return $this->getTimePresentation($this->getLastSubmissionOfRelativeDeadline());
        }

        return "";
    }



    public function exceededOfficialDeadline()
    {
        $od = $this->getOfficialDeadline();
        if ($od && $od < time()) {
            return true;
        }
        return false;
    }

    public function getRemainingTimePresentation()
    {
        $lng = $this->lng;
        $official_deadline = $this->getOfficialDeadline();
        if ($official_deadline == 0) {
            return $lng->txt("exc_no_deadline_specified");
        }
        if ($official_deadline - $this->time <= 0) {
            $time_str = $lng->txt("exc_time_over_short");
        } else {
            $time_str = ilUtil::period2String(new ilDateTime($official_deadline, IL_CAL_UNIX));
        }

        return $time_str;
    }

    public function getIndividualDeadline()
    {
        if ($this->idl->getIndividualDeadline() > $this->getCommonDeadline()) {
            return $this->idl->getIndividualDeadline();
        }
        return 0;
    }


    public function getIndividualDeadlinePresentation()
    {
        if ($this->getIndividualDeadline() > 0) {
            return $this->getTimePresentation($this->getIndividualDeadline());
        }

        return "";
    }

    public function getCommonDeadline()
    {
        if ($this->assignment->getDeadlineMode() == ilExAssignment::DEADLINE_ABSOLUTE) {        // absolute deadline
            return $this->assignment->getDeadline();
        }

        return $this->getCalculatedDeadline();
    }

    public function getCommonDeadlinePresentation()
    {
        if ($this->getCommonDeadline() > 0) {
            return $this->getTimePresentation($this->getCommonDeadline());
        }

        return "no deadline";
    }

    public function getEffectiveDeadline()
    {
        return max($this->getOfficialDeadline(), $this->assignment->getExtendedDeadline());
    }

    public function getPeerReviewDeadline()
    {
        if ($this->assignment->getPeerReview() &&
            $this->assignment->getPeerReviewDeadline()) {
            return $this->assignment->getPeerReviewDeadline();
        }
        return 0;
    }

    public function getPeerReviewDeadlinePresentation()
    {
        if ($this->getPeerReviewDeadline() > 0) {
            return $this->getTimePresentation($this->getPeerReviewDeadline());
        }

        return "no peer review deadline";
    }

    public function isPeerReviewAllowed()
    {
        if ($this->assignment->getPeerReview() && $this->hasSubmissionEndedForAllUsers()
            && ($this->getPeerReviewDeadline() == 0 || $this->getPeerReviewDeadline() > $this->time)) {
            return true;
        }

        return false;
    }

    protected function getTimePresentation($a_timestamp)
    {
        if ($a_timestamp > 0) {
            return ilDatePresentation::formatDate(new ilDateTime($a_timestamp, IL_CAL_UNIX));
        }

        return "";
    }

    public function areInstructionsVisible()
    {
        return $this->hasSubmissionStarted();
    }

    /*
    function getLateSubmissionWarning()
    {
        $lng = $this->lng;
        $late_dl = "";

        // official deadline is done, but submission still allowed
        if ($this->inLateSubmissionPhase())
        {
            // extended deadline date should not be presented anywhere
            $late_dl = $this->getTimePresentation($this->getOfficialDeadline());
            $late_dl = "<br />".sprintf($lng->txt("exc_late_submission_warning"), $late_dl);
            $late_dl = '<span class="warning">'.$late_dl.'</span>';
        }

        return $late_dl;
    }*/
    
    public function inLateSubmissionPhase()
    {
        // official deadline is done, but submission still allowed
        if ($this->getOfficialDeadline() &&
            $this->getOfficialDeadline() < $this->time &&
            $this->isSubmissionAllowed()) {
            return true;
        }
        return false;
    }
    

    public function hasSubmissionStarted()
    {
        if ($this->hasGenerallyStarted() && ($this->assignment->getDeadlineMode() == ilExAssignment::DEADLINE_ABSOLUTE ||
                $this->getIndividualStart() > 0)) {
            return true;
        }
        return false;
    }

    public function hasSubmissionEnded()
    {
        if ($this->getEffectiveDeadline() == 0) {
            return false;
        }

        if ($this->time > $this->getEffectiveDeadline()) {
            return true;
        }
        return false;
    }

    public function hasSubmissionEndedForAllUsers()
    {
        $global_subm_end = max($this->getEffectiveDeadline(), $this->assignment->getLastPersonalDeadline());

        if ($global_subm_end == 0) {
            return false;
        }

        if ($this->time > $global_subm_end) {
            return true;
        }
        return false;
    }



    public function isSubmissionAllowed()
    {
        if ($this->hasSubmissionStarted() && !$this->hasSubmissionEnded()) {
            return true;
        }
        return false;
    }

    public function isGlobalFeedbackFileAccessible(ilExSubmission $submission)
    {
        $access = false;

        if (!$this->assignment->getFeedbackFile()) {
            return false;
        }

        // global feedback / sample solution
        if ($this->assignment->getFeedbackDate() == ilExAssignment::FEEDBACK_DATE_DEADLINE) {
            $access = $this->hasSubmissionEndedForAllUsers();
        } elseif ($this->assignment->getFeedbackDate() == ilExAssignment::FEEDBACK_DATE_CUSTOM) {
            $access = $this->assignment->afterCustomDate();
        } else {
            $access = $submission->hasSubmitted();
        }

        return $access;
    }
}