class.ilExcAssMemberState.php

Go to the documentation of this file.

<?php
 
class ilExcAssMemberState
{
    protected int $ass_id;
    protected int $user_id;
    protected ilExAssignment $assignment;
    protected int $time;
    protected ilLanguage $lng;
 
    protected ?int $member_id;
    protected ?int $team_id = 0;
    protected bool $is_team = false;
    protected ilExcIndividualDeadline $idl;
 
    protected function __construct(
        ilExAssignment $a_ass,
        ilObjUser $a_user,
        ilExcIndividualDeadline $a_idl,
        int $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;
    }
 
    // Get instance by IDs (recommended for consumer code)
    public static function getInstanceByIds(
        int $a_ass_id,
        int $a_user_id = 0
    ): ilExcAssMemberState {
        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,
        int $a_time,
        ilLanguage $lng,
        ilExAssignmentTeam $a_team = null
    ): ilExcAssMemberState {
        return new self($a_ass, $a_user, $a_idl, $a_time, $lng, $a_team);
    }
 
    public function getIndividualDeadlineObject(): ilExcIndividualDeadline
    {
        return $this->idl;
    }
 
    public function getGeneralStart(): ?int
    {
        return $this->assignment->getStartTime();
    }
 
    public function getGeneralStartPresentation(): string
    {
        if ($this->getGeneralStart()) {
            return $this->getTimePresentation($this->getGeneralStart());
        }
        return "";
    }
 
    public function getIndividualStart(): int
    {
        if ($this->assignment->getDeadlineMode() == ilExAssignment::DEADLINE_RELATIVE) {
            return $this->idl->getStartingTimestamp();
        }
        return 0;
    }
 
    public function hasGenerallyStarted(): bool
    {
        return !$this->assignment->notStartedYet();
    }
 
    public function getCalculatedDeadline(): int
    {
        $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(): int
    {
        if ($this->assignment->getDeadlineMode() == ilExAssignment::DEADLINE_RELATIVE) {
            return $this->assignment->getRelativeDeadline();
        }
        return 0;
    }
 
    public function getLastSubmissionOfRelativeDeadline(): int
    {
        if ($this->assignment->getDeadlineMode() == ilExAssignment::DEADLINE_RELATIVE) {
            return $this->assignment->getRelDeadlineLastSubmission();
        }
        return 0;
    }
 
    public function getRelativeDeadlinePresentation(): string
    {
        if ($this->assignment->getDeadlineMode() == ilExAssignment::DEADLINE_RELATIVE) {
            return $this->getRelativeDeadline() . " " . $this->lng->txt("days");
        }
        return "";
    }
 
    public function getOfficialDeadline(): int
    {
        $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(): string
    {
        if ($this->getOfficialDeadline() > 0) {
            return $this->getTimePresentation($this->getOfficialDeadline());
        }
 
        return "";
    }
 
    public function getLastSubmissionOfRelativeDeadlinePresentation(): string
    {
        if ($this->getLastSubmissionOfRelativeDeadline() > 0) {
            return $this->getTimePresentation($this->getLastSubmissionOfRelativeDeadline());
        }
 
        return "";
    }
 
    // Check if official deadline exists and has ended
    public function exceededOfficialDeadline(): bool
    {
        $od = $this->getOfficialDeadline();
        if ($od && $od < time()) {
            return true;
        }
        return false;
    }
 
    public function getRemainingTimePresentation(): string
    {
        $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 = ilLegacyFormElementsUtil::period2String(new ilDateTime($official_deadline, IL_CAL_UNIX));
        }
 
        return $time_str;
    }
 
    public function getIndividualDeadline(): int
    {
        if ($this->idl->getIndividualDeadline() > $this->getCommonDeadline()) {
            return $this->idl->getIndividualDeadline();
        }
        return 0;
    }
 
    public function getIndividualDeadlinePresentation(): string
    {
        if ($this->getIndividualDeadline() > 0) {
            return $this->getTimePresentation($this->getIndividualDeadline());
        }
 
        return "";
    }
 
    // Get common deadline (no individual deadline or grace period included)
    public function getCommonDeadline(): int
    {
        if ($this->assignment->getDeadlineMode() == ilExAssignment::DEADLINE_ABSOLUTE) {        // absolute deadline
            return $this->assignment->getDeadline();
        }
 
        return $this->getCalculatedDeadline();
    }
 
    public function getCommonDeadlinePresentation(): string
    {
        if ($this->getCommonDeadline() > 0) {
            return $this->getTimePresentation($this->getCommonDeadline());
        }
 
        return "no deadline";
    }
 
    // Get effective deadline (max of official deadline and grace end period) for the user
    public function getEffectiveDeadline(): int
    {
        return max($this->getOfficialDeadline(), $this->assignment->getExtendedDeadline());
    }
 
    public function getPeerReviewDeadline(): int
    {
        if ($this->assignment->getPeerReview() &&
            $this->assignment->getPeerReviewDeadline()) {
            return $this->assignment->getPeerReviewDeadline();
        }
        return 0;
    }
 
    public function getPeerReviewDeadlinePresentation(): string
    {
        if ($this->getPeerReviewDeadline() > 0) {
            return $this->getTimePresentation($this->getPeerReviewDeadline());
        }
 
        return "no peer review deadline";
    }
 
    // Is peer reviewing currently allowed
    public function isPeerReviewAllowed(): bool
    {
        if ($this->assignment->getPeerReview() && $this->hasSubmissionEndedForAllUsers()
            && ($this->getPeerReviewDeadline() == 0 || $this->getPeerReviewDeadline() > $this->time)) {
            return true;
        }
 
        return false;
    }
 
    protected function getTimePresentation($a_timestamp): string
    {
        if ($a_timestamp > 0) {
            return ilDatePresentation::formatDate(new ilDateTime($a_timestamp, IL_CAL_UNIX));
        }
 
        return "";
    }
 
    public function areInstructionsVisible(): bool
    {
        return $this->hasSubmissionStarted();
    }
 
    public function inLateSubmissionPhase(): bool
    {
        // official deadline is done, but submission still allowed
        if ($this->getOfficialDeadline() &&
            $this->getOfficialDeadline() < $this->time &&
            $this->isSubmissionAllowed()) {
            return true;
        }
        return false;
    }
 
 
    public function hasSubmissionStarted(): bool
    {
        if ($this->hasGenerallyStarted() && ($this->assignment->getDeadlineMode() == ilExAssignment::DEADLINE_ABSOLUTE ||
                $this->getIndividualStart() > 0)) {
            return true;
        }
        return false;
    }
 
    // Check if the submission phase has ended for the current user
    public function hasSubmissionEnded(): bool
    {
        if ($this->getEffectiveDeadline() == 0) {
            return false;
        }
 
        if ($this->time > $this->getEffectiveDeadline()) {
            return true;
        }
        return false;
    }
 
    // Has submission ended for all users
    public function hasSubmissionEndedForAllUsers(): bool
    {
        $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(): bool
    {
        if ($this->hasSubmissionStarted() && !$this->hasSubmissionEnded()) {
            return true;
        }
        return false;
    }
 
    // Is global feedback file accessible?
    public function isGlobalFeedbackFileAccessible(ilExSubmission $submission): bool
    {
        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;
    }
}