mirror of
https://github.com/FH-Complete/FHC-Core.git
synced 2026-06-01 12:19:28 +00:00
Johann Hoffmann
1807 lines
67 KiB
PHP
1807 lines
67 KiB
PHP
<?php
|
|
/**
|
|
* Copyright (C) 2024 fhcomplete.org
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
if (! defined('BASEPATH')) exit('No direct script access allowed');
|
|
|
|
use CI3_Events as Events;
|
|
|
|
class Abgabe extends FHCAPI_Controller
|
|
{
|
|
|
|
/**
|
|
* Object initialization
|
|
*/
|
|
public function __construct()
|
|
{
|
|
parent::__construct([
|
|
'getConfig' => array('basis/abgabe_assistenz:rw', 'basis/abgabe_lektor:rw'),
|
|
'getConfigStudent' => array('basis/abgabe_assistenz:rw', 'basis/abgabe_student:rw', 'basis/abgabe_lektor:rw'),
|
|
'getStudentProjektarbeiten' => array('basis/abgabe_assistenz:rw', 'basis/abgabe_student:rw', 'basis/abgabe_lektor:rw'),
|
|
'getStudentProjektabgaben' => array('basis/abgabe_assistenz:rw', 'basis/abgabe_student:rw', 'basis/abgabe_lektor:rw'),
|
|
'postStudentProjektarbeitZwischenabgabe' => array('basis/abgabe_assistenz:rw', 'basis/abgabe_student:rw'),
|
|
'postStudentProjektarbeitEndupload' => array('basis/abgabe_assistenz:rw', 'basis/abgabe_student:rw'),
|
|
'postStudentProjektarbeitTitel' => array('basis/abgabe_assistenz:rw', 'basis/abgabe_student:rw'),
|
|
'getMitarbeiterProjektarbeiten' => array('basis/abgabe_assistenz:rw', 'basis/abgabe_lektor:rw'),
|
|
'postProjektarbeitAbgabe' => array('basis/abgabe_assistenz:rw', 'basis/abgabe_lektor:rw'),
|
|
'patchProjektarbeitAbgabeMultiple' => array('basis/abgabe_assistenz:rw'),
|
|
'deleteProjektarbeitAbgabe' => array('basis/abgabe_assistenz:rw', 'basis/abgabe_lektor:rw'),
|
|
'deleteProjektarbeitAbgabeMultiple' => array('basis/abgabe_assistenz:rw'),
|
|
'postSerientermin' => array('basis/abgabe_assistenz:rw', 'basis/abgabe_lektor:rw'),
|
|
'fetchDeadlines' => array('basis/abgabe_assistenz:rw', 'basis/abgabe_lektor:rw'),
|
|
'getPaAbgabetypen' => self::PERM_LOGGED,
|
|
'getNoten' => self::PERM_LOGGED,
|
|
'getProjektarbeitenForStudiengang' =>array('basis/abgabe_assistenz:rw'),
|
|
'getStudiengaenge' => array('basis/abgabe_assistenz:rw'),
|
|
'getStudentProjektarbeitAbgabeFile' => array('basis/abgabe_student:rw', 'basis/abgabe_lektor:rw', 'basis/abgabe_assistenz:rw'),
|
|
'postStudentProjektarbeitZusatzdaten' => array('basis/abgabe_lektor:rw', 'basis/abgabe_assistenz:rw'),
|
|
'getSignaturStatusForProjektarbeitAbgaben' => array('basis/abgabe_lektor:rw', 'basis/abgabe_assistenz:rw')
|
|
]);
|
|
|
|
$this->load->library('PhrasesLib');
|
|
$this->load->library('SignatureLib');
|
|
|
|
// Loads LogLib with different debug trace levels to get data of the job that extends this class
|
|
// It also specify parameters to set database fields
|
|
$this->load->library('LogLib', array(
|
|
'classIndex' => 5,
|
|
'functionIndex' => 5,
|
|
'lineIndex' => 4,
|
|
'dbLogType' => 'API', // required
|
|
'dbExecuteUser' => 'RESTful API',
|
|
'requestId' => 'API',
|
|
'requestDataFormatter' => function ($data) {
|
|
return json_encode($data);
|
|
}
|
|
), 'logLib');
|
|
|
|
$this->loadPhrases(
|
|
array(
|
|
'global',
|
|
'ui',
|
|
'abgabetool'
|
|
)
|
|
);
|
|
$this->load->config('abgabe');
|
|
$this->load->helper('hlp_sancho_helper');
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------------------------------
|
|
// Public methods
|
|
|
|
/**
|
|
* loads config related to abgabetool, found in application/config/abgabe
|
|
*/
|
|
public function getConfig() {
|
|
$old_abgabe_beurteilung_link =$this->config->item('old_abgabe_beurteilung_link');
|
|
$turnitin_link = $this->config->item('turnitin_link');
|
|
$abgabetypenBetreuer = $this->config->item('ALLOWED_ABGABETYPEN_BETREUER');
|
|
$ASSISTENZ_SAMMELMAIL_BUTTON_STUDENT = $this->config->item('ASSISTENZ_SAMMELMAIL_BUTTON_STUDENT');
|
|
$ASSISTENZ_SAMMELMAIL_BUTTON_BETREUER = $this->config->item('ASSISTENZ_SAMMELMAIL_BUTTON_BETREUER');
|
|
$BETREUER_SAMMELMAIL_BUTTON_STUDENT = $this->config->item('BETREUER_SAMMELMAIL_BUTTON_STUDENT');
|
|
$MULTIEDIT_TABLE = $this->config->item('MULTIEDIT_TABLE');
|
|
|
|
$ret = array(
|
|
'old_abgabe_beurteilung_link' => $old_abgabe_beurteilung_link,
|
|
'turnitin_link' => $turnitin_link,
|
|
'abgabetypenBetreuer' => $abgabetypenBetreuer,
|
|
'ASSISTENZ_SAMMELMAIL_BUTTON_STUDENT' => $ASSISTENZ_SAMMELMAIL_BUTTON_STUDENT,
|
|
'ASSISTENZ_SAMMELMAIL_BUTTON_BETREUER' => $ASSISTENZ_SAMMELMAIL_BUTTON_BETREUER,
|
|
'MULTIEDIT_TABLE' => $MULTIEDIT_TABLE,
|
|
);
|
|
|
|
$this->terminateWithSuccess($ret);
|
|
}
|
|
|
|
/**
|
|
* loads config related to abgabetool for students to avoid handing out links reserved for employees
|
|
*/
|
|
public function getConfigStudent() {
|
|
$moodle_link = $this->config->item('STG_MOODLE_LINK');
|
|
$title_edit_allowed = $this->config->item('STUDENT_EDIT_PROJEKTARBEIT_TITLE');
|
|
$confetti_on_endupload = $this->config->item('CONFETTI_ON_ENDUPLOAD');
|
|
$siginfolink_german = $this->config->item('SIGNATUR_INFO_LINK_GERMAN');
|
|
$siginfolink_english = $this->config->item('SIGNATUR_INFO_LINK_ENGLISH');
|
|
|
|
$ret = array(
|
|
'moodle_link' => $moodle_link,
|
|
'title_edit_allowed' => $title_edit_allowed,
|
|
'confetti_on_endupload' => $confetti_on_endupload,
|
|
'siginfolink_german' => $siginfolink_german,
|
|
'siginfolink_english' => $siginfolink_english
|
|
);
|
|
|
|
$this->terminateWithSuccess($ret);
|
|
}
|
|
|
|
/**
|
|
* fetches all projektabgabetermine for a given projektarbeit_id used in cis4 student abgabetool & lektor abgabetool
|
|
*/
|
|
public function getStudentProjektabgaben() {
|
|
$projektarbeit_id = $this->input->get("projektarbeit_id",TRUE);
|
|
$this->load->model('education/Projektarbeit_model', 'ProjektarbeitModel');
|
|
|
|
if ($projektarbeit_id === NULL || trim((string)$projektarbeit_id) === '') {
|
|
$this->terminateWithError($this->p->t('global', 'wrongParameters'), 'general');
|
|
}
|
|
|
|
$result = $this->ProjektarbeitModel->load($projektarbeit_id);
|
|
$projektarbeitArr = $this->getDataOrTerminateWithError($result, 'general');
|
|
|
|
if(count($projektarbeitArr) > 0) {
|
|
$projektarbeit = $projektarbeitArr[0];
|
|
} else {
|
|
$this->terminateWithError($this->p->t('abgabetool','c4projektarbeitNichtGefunden'), 'general');
|
|
}
|
|
|
|
$res = $this->ProjektarbeitModel->getStudentInfoForProjektarbeitId($projektarbeit_id);
|
|
if(isError($res)) {
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4errorLoadingStudentForProjektarbeitID'), 'general');
|
|
}
|
|
|
|
if(!hasData($res)) {
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4noAssignedStudentForProjektarbeitID'), 'general');
|
|
}
|
|
$data = getData($res)[0];
|
|
$student_uid = $data->uid;
|
|
|
|
$zugeordnet = $this->checkZuordnung($projektarbeit_id, getAuthUID());
|
|
if(getAuthUID() == $student_uid || $zugeordnet) {
|
|
$projektarbeitIsCurrent = false;
|
|
$returnFunc = function ($result) use (&$projektarbeitIsCurrent) {
|
|
$projektarbeitIsCurrent = $result;
|
|
};
|
|
Events::trigger('projektarbeit_is_current', $projektarbeit_id, $returnFunc);
|
|
|
|
$ret = $this->ProjektarbeitModel->getProjektarbeitAbgabetermine($projektarbeit_id);
|
|
|
|
foreach ($ret->retval as $termin) {
|
|
$this->checkAbgabeSignatur($termin, $projektarbeit->student_uid);
|
|
}
|
|
|
|
$this->terminateWithSuccess(array($ret, $projektarbeitIsCurrent));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* fetches all projektarbeiten and betreuer for a given student_uid used in cis4 student abgabetool
|
|
*/
|
|
public function getStudentProjektarbeiten()
|
|
{
|
|
$uid = $this->input->get("uid",TRUE);
|
|
|
|
$this->load->model('person/Person_model', 'PersonModel');
|
|
$this->load->model('ressource/Mitarbeiter_model', 'MitarbeiterModel');
|
|
$this->load->model('education/Projektarbeit_model', 'ProjektarbeitModel');
|
|
|
|
// if uid is missing or empty, fall back to getAuthUID()
|
|
if ($uid === NULL || trim((string)$uid) === '') {
|
|
$uid = getAuthUID();
|
|
}
|
|
|
|
$isMitarbeiter = $this->MitarbeiterModel->isMitarbeiter(getAuthUID());
|
|
if ($isMitarbeiter) {
|
|
$result = $this->ProjektarbeitModel->getStudentProjektarbeitenWithBetreuer($uid);
|
|
} else {
|
|
$result = $this->ProjektarbeitModel->getStudentProjektarbeitenWithBetreuer(getAuthUID());
|
|
}
|
|
|
|
$projektarbeiten = hasData($result) ? getData($result) : array();
|
|
|
|
if(count($projektarbeiten)) {
|
|
foreach($projektarbeiten as $pa) {
|
|
|
|
$pa->student = getData($this->PersonModel->getFullName($uid));
|
|
|
|
$downloadPaFunc = function ($babgeschickt, $zweitbetreuer_abgeschickt) use ($pa) {
|
|
$pa->babgeschickt = $babgeschickt;
|
|
$pa->zweitbetreuer_abgeschickt = $zweitbetreuer_abgeschickt;
|
|
};
|
|
|
|
Events::trigger('projektbeurteilung_check_available', $pa->projektarbeit_id, $pa->bperson_id, $downloadPaFunc);
|
|
|
|
if(isset($pa->babgeschickt) && $pa->babgeschickt) {
|
|
$downloadLink1 = '';
|
|
$downloadLinkFunc1 = function ($link) use (&$downloadLink1) {
|
|
$downloadLink1 = $link;
|
|
};
|
|
|
|
Events::trigger('projektbeurteilung_download_link', $pa->projektarbeit_id, $pa->betreuerart_kurzbz, $pa->bperson_id, $downloadLinkFunc1);
|
|
|
|
// use config fallback in case the event fails
|
|
if($downloadLink1 == '') {
|
|
$fallback = $this->config->item('beurteilung_link_fallback');
|
|
|
|
$search = array(
|
|
'betreuerart_kurzbz=?',
|
|
'projektarbeit_id=?',
|
|
'person_id=?'
|
|
);
|
|
|
|
$replace = array(
|
|
'betreuerart_kurzbz=' . $pa->betreuerart_kurzbz,
|
|
'projektarbeit_id=' . $pa->projektarbeit_id,
|
|
'person_id=' . $pa->bperson_id
|
|
);
|
|
|
|
$fallback = str_replace($search, $replace, $fallback);
|
|
$downloadLink1 = APP_ROOT.$fallback;
|
|
|
|
}
|
|
$pa->downloadLink1 = $downloadLink1;
|
|
}
|
|
|
|
$pa->email = $pa->mitarbeiter_uid.'@'.DOMAIN;
|
|
|
|
if($pa->zweitbetreuer_person_id !== null) {
|
|
|
|
if($pa->zweitbetreuer_abgeschickt) {
|
|
$downloadLink2 = '';
|
|
$downloadLinkFunc2 = function ($link) use (&$downloadLink2) {
|
|
$downloadLink2 = $link;
|
|
};
|
|
|
|
Events::trigger('projektbeurteilung_download_link', $pa->projektarbeit_id, $pa->zweitbetreuer_betreuerart_kurzbz, $pa->zweitbetreuer_person_id, $downloadLinkFunc2);
|
|
|
|
// use config fallback in case the event fails
|
|
if($downloadLink2 == '') {
|
|
$fallback = $this->config->item('beurteilung_link_fallback');
|
|
|
|
$search = array(
|
|
'betreuerart_kurzbz=?',
|
|
'projektarbeit_id=?',
|
|
'person_id=?'
|
|
);
|
|
|
|
$replace = array(
|
|
'betreuerart_kurzbz=' . $pa->zweitbetreuer_betreuerart_kurzbz,
|
|
'projektarbeit_id=' . $pa->projektarbeit_id,
|
|
'person_id=' . $pa->zweitbetreuer_person_id
|
|
);
|
|
|
|
$fallback = str_replace($search, $replace, $fallback);
|
|
$downloadLink2 = APP_ROOT.$fallback;
|
|
|
|
}
|
|
|
|
$pa->downloadLink2 = $downloadLink2;
|
|
}
|
|
|
|
$result = $this->ProjektarbeitModel->getProjektbetreuerAnrede($pa->zweitbetreuer_person_id);
|
|
|
|
$data = getData($result);
|
|
if(count($data) > 0) {
|
|
$pa->zweitbetreuer = $data[0];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
$this->terminateWithSuccess(array($projektarbeiten));
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* projektarbeit - upload for zwischenabgaben in cis4 student abgabetool
|
|
*/
|
|
public function postStudentProjektarbeitZwischenabgabe()
|
|
{
|
|
$this->checkUploadSize();
|
|
|
|
$projektarbeit_id = $this->input->post('projektarbeit_id');
|
|
$paabgabe_id = $this->input->post('paabgabe_id');
|
|
$student_uid = $this->input->post('student_uid');
|
|
$bperson_id = $this->input->post('bperson_id');
|
|
$paabgabetyp_kurzbz = $this->input->post('paabgabetyp_kurzbz');
|
|
|
|
if ($projektarbeit_id === NULL || trim((string)$projektarbeit_id) === ''
|
|
|| $paabgabe_id === NULL || trim((string)$paabgabe_id) === ''
|
|
|| $student_uid === NULL || trim((string)$student_uid) === ''
|
|
|| $paabgabetyp_kurzbz === NULL || trim((string)$paabgabetyp_kurzbz) === '') {
|
|
$this->terminateWithError($this->p->t('global', 'wrongParameters'), 'general');
|
|
}
|
|
|
|
$this->checkProjektarbeitForFinishedStatus($projektarbeit_id);
|
|
|
|
$zugeordnet = $this->checkZuordnung($projektarbeit_id, getAuthUID());
|
|
if(getAuthUID() == $student_uid || $zugeordnet) {
|
|
|
|
|
|
$path = PAABGABE_PATH.$paabgabe_id.'_'.$student_uid.'.pdf';
|
|
|
|
if ((isset($_FILES) and isset($_FILES['file']) and ! $_FILES['file']['error'])) {
|
|
move_uploaded_file($_FILES['file']['tmp_name'], $path);
|
|
|
|
if(file_exists($path)) {
|
|
|
|
chmod($path, 0640);
|
|
|
|
$this->load->model('education/Paabgabe_model', 'PaabgabeModel');
|
|
$res = $this->PaabgabeModel->update($paabgabe_id, array(
|
|
'abgabedatum' => date('Y-m-d'),
|
|
'updatevon' => getAuthUID(),
|
|
'updateamum' => date('Y-m-d H:i:s')
|
|
));
|
|
|
|
$this->logLib->logInfoDB(array('zwischenupload',$res, array(
|
|
'abgabedatum' => date('Y-m-d'),
|
|
'updatevon' => getAuthUID(),
|
|
'updateamum' => date('Y-m-d H:i:s')
|
|
), getAuthUID(), getAuthPersonId(), $student_uid));
|
|
|
|
$this->terminateWithSuccess($res);
|
|
} else {
|
|
$this->terminateWithError('Error moving File', 'general');
|
|
}
|
|
|
|
} else {
|
|
$this->terminateWithError('File missing', 'general');
|
|
}
|
|
} else {
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4noZuordnungBetreuerStudent'));
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* upload für finale abgaben aka Endupload in cis4 student abgabetool
|
|
*/
|
|
public function postStudentProjektarbeitEndupload()
|
|
{
|
|
$this->checkUploadSize();
|
|
|
|
$projektarbeit_id = $this->input->post('projektarbeit_id');
|
|
$paabgabe_id = $this->input->post('paabgabe_id');
|
|
$student_uid = $this->input->post('student_uid');
|
|
$sprache = $this->input->post('sprache');
|
|
$abstract = $this->input->post('abstract');
|
|
$abstract_en = $this->input->post('abstract_en');
|
|
$schlagwoerter = $this->input->post('schlagwoerter');
|
|
$schlagwoerter_en = $this->input->post('schlagwoerter_en');
|
|
$seitenanzahl = $this->input->post('seitenanzahl');
|
|
$bperson_id = $this->input->post('bperson_id');
|
|
$paabgabetyp_kurzbz = $this->input->post('paabgabetyp_kurzbz');
|
|
|
|
if ($projektarbeit_id === NULL || trim((string)$projektarbeit_id) === ''
|
|
|| $paabgabe_id === NULL || trim((string)$paabgabe_id) === ''
|
|
|| $student_uid === NULL || trim((string)$student_uid) === ''
|
|
|| $paabgabetyp_kurzbz === NULL || trim((string)$paabgabetyp_kurzbz) === ''
|
|
|| $abstract === NULL || $abstract_en === NULL
|
|
|| $schlagwoerter === NULL || $schlagwoerter_en === NULL
|
|
|| $seitenanzahl === NULL || $sprache === NULL) {
|
|
$this->terminateWithError($this->p->t('global', 'wrongParameters'), 'general');
|
|
}
|
|
|
|
$this->checkPaabgabeDeadline($paabgabe_id);
|
|
|
|
$this->checkProjektarbeitForFinishedStatus($projektarbeit_id);
|
|
|
|
$zugeordnet = $this->checkZuordnung($projektarbeit_id, getAuthUID());
|
|
if(getAuthUID() == $student_uid || $zugeordnet) {
|
|
if ((isset($_FILES) and isset($_FILES['file']) and !$_FILES['file']['error'])) {
|
|
move_uploaded_file($_FILES['file']['tmp_name'], PAABGABE_PATH . $paabgabe_id . '_' . $student_uid . '.pdf');
|
|
|
|
if (file_exists(PAABGABE_PATH . $paabgabe_id . '_' . $student_uid . '.pdf')) {
|
|
|
|
$this->load->model('education/Projektarbeit_model', 'ProjektarbeitModel');
|
|
|
|
$result = $this->ProjektarbeitModel->load($projektarbeit_id);
|
|
$projektarbeitArr = $this->getDataOrTerminateWithError($result, 'general');
|
|
|
|
if (count($projektarbeitArr) > 0) {
|
|
$projektarbeit = $projektarbeitArr[0];
|
|
} else {
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4projektarbeitNichtGefunden'), 'general');
|
|
}
|
|
|
|
$this->load->model('education/Paabgabe_model', 'PaabgabeModel');
|
|
$result = $this->PaabgabeModel->load($paabgabe_id);
|
|
$paabgabeArr = $this->getDataOrTerminateWithError($result, 'general');
|
|
|
|
if (count($paabgabeArr) > 0) {
|
|
$paabgabe = $paabgabeArr[0];
|
|
} else {
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4projektabgabeNichtGefunden'), 'general');
|
|
}
|
|
|
|
$this->checkAbgabeSignatur($paabgabe, $projektarbeit->student_uid);
|
|
$signaturstatus = $paabgabe->signatur;
|
|
|
|
// update projektarbeit cols with zusatzdaten AND abgabedatum!
|
|
$this->ProjektarbeitModel->update($projektarbeit->projektarbeit_id, array(
|
|
'sprache' => $sprache,
|
|
'seitenanzahl' => $seitenanzahl,
|
|
'abgabedatum' => date('Y-m-d'),
|
|
'schlagwoerter_en' => $schlagwoerter_en,
|
|
'schlagwoerter' => $schlagwoerter,
|
|
'abstract' => $abstract,
|
|
'abstract_en' => $abstract_en
|
|
));
|
|
|
|
|
|
// update paabgabe datum
|
|
$res = $this->PaabgabeModel->update($paabgabe_id, array(
|
|
'abgabedatum' => date('Y-m-d'),
|
|
'updatevon' => getAuthUID(),
|
|
'updateamum' => date('Y-m-d H:i:s')
|
|
));
|
|
|
|
$res = $this->PaabgabeModel->load($res->retval);
|
|
$abgabe = getData($res)[0];
|
|
$abgabe->signatur = $signaturstatus;
|
|
|
|
$this->sendUploadEmail($bperson_id, $projektarbeit_id, $paabgabetyp_kurzbz, $student_uid);
|
|
|
|
$this->logLib->logInfoDB(array('endupload', $res, array(
|
|
'abgabedatum' => date('Y-m-d'),
|
|
'updatevon' => getAuthUID(),
|
|
'updateamum' => date('Y-m-d H:i:s')
|
|
), getAuthUID(), getAuthPersonId(), array($projektarbeit_id, $sprache, $abstract, $abstract_en
|
|
, $schlagwoerter, $schlagwoerter_en, $seitenanzahl)));
|
|
|
|
$this->terminateWithSuccess($abgabe);
|
|
} else {
|
|
$this->terminateWithError('Error moving File', 'general');
|
|
}
|
|
|
|
} else {
|
|
$this->terminateWithError('File missing', 'general');
|
|
}
|
|
} else {
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4noZuordnungBetreuerStudent'));
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* POST METHOD
|
|
* allows a student (or assistenz on their behalf) to update the titel of their own projektarbeit.
|
|
* blocked once the projektarbeit has been graded (checkProjektarbeitForFinishedStatus).
|
|
*/
|
|
public function postStudentProjektarbeitTitel()
|
|
{
|
|
if(!$this->config->item('STUDENT_EDIT_PROJEKTARBEIT_TITLE')) {
|
|
$this->terminateWithError($this->p->t('global', 'c4studentEditNotAllowed'), 'general');
|
|
};
|
|
|
|
$projektarbeit_id = $this->input->post('projektarbeit_id');
|
|
$titel = $this->input->post('titel');
|
|
|
|
if ($projektarbeit_id === NULL || trim((string)$projektarbeit_id) === ''
|
|
|| $titel === NULL || trim((string)$titel) === '') {
|
|
$this->terminateWithError($this->p->t('global', 'wrongParameters'), 'general');
|
|
}
|
|
|
|
// strip all HTML tags to prevent XSS in mail bodies, table views and Projektarbeitsbenotung
|
|
$titel = trim(strip_tags($titel));
|
|
if ($titel === '') {
|
|
$this->terminateWithError($this->p->t('global', 'wrongParameters'), 'general');
|
|
}
|
|
|
|
// Reject emojis and pictographs
|
|
// allows foreign letters, math symbols, accents, and standard punctuation.
|
|
$emojiPattern = '/[\x{1F300}-\x{1F5FF}\x{1F600}-\x{1F64F}\x{1F680}-\x{1F6FF}\x{1F900}-\x{1FAFF}\x{23E9}-\x{23EF}\x{2b50}\x{2700}-\x{27BF}]/u';
|
|
|
|
// i would like this much more but our server does not recognize this utf-8 character range this way, so hexcodes it is
|
|
// if (preg_match('/\p{Extended_Pictographic}/u', $titel)) {
|
|
if (preg_match($emojiPattern, $titel)) {
|
|
|
|
$this->terminateWithError($this->p->t('global', 'wrongParameters'), 'general');
|
|
}
|
|
|
|
$this->checkProjektarbeitForFinishedStatus($projektarbeit_id);
|
|
|
|
$this->load->model('education/Projektarbeit_model', 'ProjektarbeitModel');
|
|
|
|
// Verify the projektarbeit actually belongs to the supplied student_uid
|
|
$res = $this->ProjektarbeitModel->getStudentInfoForProjektarbeitId($projektarbeit_id);
|
|
if (isError($res) || !hasData($res)) {
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4projektarbeitNichtGefunden'), 'general');
|
|
}
|
|
$assignedStudentUid = getData($res)[0]->uid;
|
|
|
|
// A student may only update their own title; assistenz is covered by checkZuordnung
|
|
$zugeordnet = $this->checkZuordnung($projektarbeit_id, getAuthUID());
|
|
if (getAuthUID() !== $assignedStudentUid && !$zugeordnet) {
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4noZuordnungBetreuerStudent'), 'general');
|
|
}
|
|
|
|
|
|
|
|
$result = $this->ProjektarbeitModel->load($projektarbeit_id);
|
|
$data = getData($result);
|
|
|
|
$oldTitle = $data[0]->titel ?? '';
|
|
|
|
$result = $this->ProjektarbeitModel->update(
|
|
$projektarbeit_id,
|
|
array(
|
|
'titel' => $titel,
|
|
'updatevon' => getAuthUID(),
|
|
'updateamum' => date('Y-m-d H:i:s')
|
|
)
|
|
);
|
|
|
|
$this->getDataOrTerminateWithError($result, 'general');
|
|
|
|
$this->logLib->logInfoDB(array(
|
|
'titelUpdate',
|
|
array(
|
|
'projektarbeit_id' => $projektarbeit_id,
|
|
'titel' => $titel,
|
|
'updatevon' => getAuthUID(),
|
|
'updateamum' => date('Y-m-d H:i:s')
|
|
),
|
|
getAuthUID(),
|
|
getAuthPersonId()
|
|
));
|
|
|
|
$this->sendTitelChangedEmail(
|
|
$projektarbeit_id,
|
|
$titel,
|
|
$oldTitle,
|
|
$assignedStudentUid
|
|
);
|
|
|
|
$result = $this->ProjektarbeitModel->load($projektarbeit_id);
|
|
$titel = hasData($result) ? getData($result)[0]->titel : $titel;
|
|
$this->terminateWithSuccess($titel);
|
|
}
|
|
|
|
/**
|
|
* Notifies all betreuer of a projektarbeit and all assistenzen responsible for its studiengang
|
|
* when a student updates the titel of their projektarbeit.
|
|
*
|
|
* Betreuer retrieval mirrors AbgabetoolJob->notifyBetreuerAboutChangedAbgaben.
|
|
* Assistenz retrieval mirrors AbgabetoolJob->notifyAssistenzAboutChangedAbgaben.
|
|
*
|
|
* @param int $projektarbeit_id
|
|
* @param string $new_titel The titel as it was saved
|
|
* @param string $student_uid
|
|
*/
|
|
private function sendTitelChangedEmail($projektarbeit_id, $new_titel, $old_titel, $student_uid)
|
|
{
|
|
$this->load->model('education/Projektarbeit_model', 'ProjektarbeitModel');
|
|
$this->load->model('education/Projektbetreuer_model', 'ProjektbetreuerModel');
|
|
$this->load->model('organisation/Studiengang_model', 'StudiengangModel');
|
|
$this->load->model('organisation/Organisationseinheit_model', 'OrganisationseinheitModel');
|
|
$this->load->model('person/Person_model', 'PersonModel');
|
|
|
|
$this->load->model('person/Person_model', 'PersonModel');
|
|
$studentNameResult = $this->PersonModel->getFullName($student_uid);
|
|
$studentFullName = hasData($studentNameResult) ? getData($studentNameResult) : $student_uid;
|
|
|
|
$studentInfoResult = $this->ProjektarbeitModel->getStudentInfoForProjektarbeitId($projektarbeit_id);
|
|
if (isError($studentInfoResult) || !hasData($studentInfoResult)) {
|
|
$this->logLib->logInfoDB(array('sendTitelChangedEmail: student info not found', $projektarbeit_id));
|
|
return;
|
|
}
|
|
$studentInfo = getData($studentInfoResult)[0];
|
|
$studiengang_kz = $studentInfo->studiengang_kz;
|
|
|
|
$stgResult = $this->StudiengangModel->load($studiengang_kz);
|
|
$oe_kurzbz = null;
|
|
if (!isError($stgResult) && hasData($stgResult)) {
|
|
$oe_kurzbz = getData($stgResult)[0]->oe_kurzbz ?? null;
|
|
}
|
|
|
|
// build shared mail data
|
|
$base_mail_data = array(
|
|
'studentFullName' => $studentFullName,
|
|
'new_titel' => $new_titel,
|
|
'old_titel' => $old_titel
|
|
);
|
|
|
|
// notify all betreuer
|
|
$betreuerResult = $this->ProjektbetreuerModel->getAllBetreuerOfProjektarbeit($projektarbeit_id);
|
|
if (!isError($betreuerResult) && hasData($betreuerResult)) {
|
|
|
|
$linkAbgabetool = APP_ROOT . $this->config->item('URL_MITARBEITER');
|
|
|
|
foreach (getData($betreuerResult) as $betreuer) {
|
|
$email = $betreuer->uid ? $betreuer->uid . '@' . DOMAIN : ($betreuer->private_email ?? null);
|
|
if (!$email) {
|
|
$this->logLib->logInfoDB(array('sendTitelChangedEmail: no email for betreuer', $betreuer->person_id));
|
|
continue;
|
|
}
|
|
|
|
$anredeResult = $this->ProjektarbeitModel->getProjektbetreuerAnrede($betreuer->person_id);
|
|
$anrede = (!isError($anredeResult) && hasData($anredeResult)) ? getData($anredeResult)[0] : null;
|
|
|
|
$mail_data = array_merge($base_mail_data, array(
|
|
'anredeFillString' => ($anrede->anrede ?? '') === 'Herr' ? 'r' : '',
|
|
'anrede' => $anrede->anrede ?? '',
|
|
'fullFormattedNameString' => $anrede->first ?? $email,
|
|
'linkAbgabetool' => $linkAbgabetool,
|
|
));
|
|
|
|
sendSanchoMail(
|
|
'PATitleUpdated',
|
|
$mail_data,
|
|
$email,
|
|
$this->p->t('abgabetool', 'c4PATitleChanged')
|
|
);
|
|
}
|
|
}
|
|
|
|
// notify assistenz for the studiengang OE
|
|
if (!$oe_kurzbz) {
|
|
$this->logLib->logInfoDB(array('sendTitelChangedEmail: no oe_kurzbz resolved, skipping assistenz', $studiengang_kz));
|
|
return;
|
|
}
|
|
|
|
$assistenzResult = $this->OrganisationseinheitModel->getAssistenzForOE($oe_kurzbz);
|
|
if (isError($assistenzResult) || !hasData($assistenzResult)) {
|
|
return;
|
|
}
|
|
|
|
$linkAbgabetool = APP_ROOT . $this->config->item('URL_ASSISTENZ');
|
|
|
|
// similar pattern as job uses via the assistenzMap
|
|
$sentTo = [];
|
|
foreach (getData($assistenzResult) as $assistenz) {
|
|
if (in_array($assistenz->person_id, $sentTo)) {
|
|
continue;
|
|
}
|
|
$sentTo[] = $assistenz->person_id;
|
|
|
|
$email = $assistenz->uid . '@' . DOMAIN;
|
|
|
|
$mail_data = array_merge($base_mail_data, array(
|
|
'anredeFillString' => $assistenz->anrede === 'Herr' ? 'r' : '',
|
|
'anrede' => $assistenz->anrede ?? '',
|
|
'fullFormattedNameString' => $assistenz->first ?? ($assistenz->uid . '@' . DOMAIN),
|
|
'linkAbgabetool' => $linkAbgabetool,
|
|
));
|
|
|
|
sendSanchoMail(
|
|
'PATitleUpdated',
|
|
$mail_data,
|
|
$email,
|
|
$this->p->t('abgabetool', 'c4PATitleChanged')
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
// validate paabgabe deadline against servertime just in case a student spoofs their local clock and thus
|
|
// unlocks the upload ui
|
|
private function checkPaabgabeDeadline($paabgabe_id) {
|
|
$this->load->model('education/Paabgabe_model', 'PaabgabeModel');
|
|
|
|
$result = $this->PaabgabeModel->load($paabgabe_id);
|
|
$paabgabeArr = $this->getDataOrTerminateWithError($result, 'general');
|
|
|
|
if (count($paabgabeArr) > 0) {
|
|
$paabgabe = $paabgabeArr[0];
|
|
} else {
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4projektabgabeNichtGefunden'), 'general');
|
|
}
|
|
|
|
// in that case any submission date is fine
|
|
if($paabgabe->fixtermin === false) return;
|
|
|
|
$tz = new DateTimeZone('Europe/Berlin');
|
|
$now = new DateTimeImmutable('now', $tz);
|
|
$deadline = DateTimeImmutable::createFromFormat(
|
|
'Y-m-d H:i:s',
|
|
$paabgabe->datum . ' 23:59:59',
|
|
$tz
|
|
);
|
|
|
|
if($now >= $deadline) {
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4deadlineExceeded'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* tabulator tabledata fetch for abgabetool/mitarbeiter
|
|
* initially fetches all currently active projektarbeiten with assigned mentorship
|
|
* showAll functionality also retrieves older finished projektarbeiten
|
|
*/
|
|
public function getMitarbeiterProjektarbeiten() {
|
|
$this->load->model('education/Projektarbeit_model', 'ProjektarbeitModel');
|
|
|
|
$boolParamStr = $this->input->get('showall');
|
|
$trueStrings = ['true', '1'];
|
|
$falseStrings = ['false', '0'];
|
|
|
|
// Handle missing or invalid parameter
|
|
if ($boolParamStr === null) {
|
|
$this->terminateWithError($this->p->t('global', 'wrongParameters'), 'general');
|
|
}
|
|
$boolParamStrLower = strtolower($boolParamStr);
|
|
|
|
$showAllBool = false; // fallback if input strings are anything else for whatever reason
|
|
if (in_array($boolParamStrLower, $trueStrings, true)) {
|
|
$showAllBool = true;
|
|
} elseif (in_array($boolParamStrLower, $falseStrings, true)) {
|
|
$showAllBool = false;
|
|
}
|
|
|
|
$projektarbeiten = $this->ProjektarbeitModel->getMitarbeiterProjektarbeiten(getAuthUID(), $showAllBool);
|
|
|
|
|
|
$mapFunc = function($projektarbeit) {
|
|
return $projektarbeit->projektarbeit_id;
|
|
};
|
|
$projektarbeiten_ids = array_map($mapFunc, $projektarbeiten->retval);
|
|
|
|
if(count($projektarbeiten_ids) > 0) {
|
|
$ret = $this->ProjektarbeitModel->getProjektarbeitenAbgabetermine($projektarbeiten_ids);
|
|
$projektabgaben = $this->getDataOrTerminateWithError($ret, 'general');
|
|
}
|
|
|
|
forEach($projektarbeiten->retval as $pa) {
|
|
|
|
$result = $this->ProjektarbeitModel->getProjektbetreuerAnrede($pa->betreuer_person_id);
|
|
$anredeArr = $this->getDataOrTerminateWithError($result, 'general');
|
|
$pa->betreuer = $anredeArr[0];
|
|
|
|
$oldLink = ''; // show this when paIsCurrent == false -> moodle course template
|
|
$newLink = ''; // get curated path for betreuer type
|
|
$returnFunc = function ( $resultOld, $resultNew) use (&$oldLink, &$newLink) {
|
|
$newLink = $resultNew;
|
|
$oldLink = $resultOld;
|
|
};
|
|
|
|
Events::trigger('projektbeurteilung_formular_link', $pa->betreuerart_kurzbz, APP_ROOT, $pa->projektarbeit_id, $pa->student_uid, $returnFunc);
|
|
$pa->beurteilungLinkNew = $newLink;
|
|
$pa->beurteilungLinkOld = $oldLink;
|
|
|
|
// has previously been retrieved via getStudentProjektabgaben but is fetched in advance to avoid having to reload abgaben
|
|
$projektarbeitIsCurrent = false;
|
|
$returnFunc = function ($result) use (&$projektarbeitIsCurrent) {
|
|
$projektarbeitIsCurrent = $result;
|
|
};
|
|
Events::trigger('projektarbeit_is_current', $pa->projektarbeit_id, $returnFunc);
|
|
$pa->isCurrent = $projektarbeitIsCurrent;
|
|
|
|
$filterFunc = function($projektabgabe) use ($pa) {
|
|
return $projektabgabe->projektarbeit_id == $pa->projektarbeit_id;
|
|
};
|
|
|
|
$pa->abgabetermine = array_values(array_filter($projektabgaben, $filterFunc));
|
|
}
|
|
|
|
|
|
$this->terminateWithSuccess(array($projektarbeiten, DOMAIN));
|
|
}
|
|
|
|
/**
|
|
* called by abgabetool/mitarbeiter in mitarbeiterdetail.js when adding a single new abgabetermin
|
|
* initially fetches all
|
|
*/
|
|
public function postProjektarbeitAbgabe() {
|
|
$projektarbeit_id = $this->input->post('projektarbeit_id');
|
|
$paabgabe_id = $this->input->post('paabgabe_id');
|
|
$paabgabetyp_kurzbz = $this->input->post('paabgabetyp_kurzbz');
|
|
$datum = $this->input->post('datum');
|
|
$fixtermin = $this->input->post('fixtermin');
|
|
$kurzbz = $this->input->post('kurzbz');
|
|
$note = $this->input->post('note');
|
|
$beurteilungsnotiz = $this->input->post('beurteilungsnotiz');
|
|
$upload_allowed = $this->input->post('upload_allowed');
|
|
$betreuer_person_id = $this->input->post('betreuer_person_id');
|
|
|
|
if ($projektarbeit_id === NULL || trim((string)$projektarbeit_id) === ''
|
|
|| $paabgabe_id === NULL || trim((string)$paabgabe_id) === ''
|
|
|| $datum === NULL || trim((string)$datum) === ''
|
|
|| $kurzbz === NULL
|
|
|| $paabgabetyp_kurzbz === NULL || trim((string)$paabgabetyp_kurzbz) === '') {
|
|
$this->terminateWithError($this->p->t('global', 'wrongParameters'), 'general');
|
|
}
|
|
|
|
$this->checkProjektarbeitForFinishedStatus($projektarbeit_id);
|
|
|
|
$zugeordnet = $this->checkZuordnung($projektarbeit_id, getAuthUID());
|
|
if(!$zugeordnet) {
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4noZuordnungBetreuerStudent'));
|
|
}
|
|
|
|
$this->load->model('education/Paabgabe_model', 'PaabgabeModel');
|
|
|
|
$existingPaabgabe = null;
|
|
if($paabgabe_id == -1) {
|
|
$result = $this->PaabgabeModel->insert(
|
|
array(
|
|
'projektarbeit_id' => $projektarbeit_id,
|
|
'paabgabetyp_kurzbz' => $paabgabetyp_kurzbz,
|
|
'fixtermin' => $fixtermin,
|
|
'datum' => $datum,
|
|
'kurzbz' => $kurzbz,
|
|
'note' => $note,
|
|
'beurteilungsnotiz' => $beurteilungsnotiz,
|
|
'upload_allowed' => $upload_allowed,
|
|
'insertvon' => getAuthUID(),
|
|
'insertamum' => date('Y-m-d H:i:s')
|
|
)
|
|
);
|
|
$this->logLib->logInfoDB(array('paabgabe created',array(
|
|
'projektarbeit_id' => $projektarbeit_id,
|
|
'paabgabetyp_kurzbz' => $paabgabetyp_kurzbz,
|
|
'fixtermin' => $fixtermin,
|
|
'datum' => $datum,
|
|
'kurzbz' => $kurzbz,
|
|
'note' => $note,
|
|
'beurteilungsnotiz' => $beurteilungsnotiz,
|
|
'upload_allowed' => $upload_allowed,
|
|
'insertvon' => getAuthUID(),
|
|
'insertamum' => date('Y-m-d H:i:s')
|
|
), getAuthUID(), getAuthPersonId()));
|
|
} else {
|
|
// load existing entry of paabgabe and check if note has changed to negativ, to avoid sending when
|
|
// only notiz has changed.
|
|
|
|
// TODO: what if paabgabe is a qualgate1, is benotet negativ and then its type is changed to gate2?
|
|
|
|
$existingResult = $this->PaabgabeModel->load($paabgabe_id);
|
|
$existingPaabgabeArr = getData($existingResult);
|
|
if(count($existingPaabgabeArr) > 0) $existingPaabgabe = $existingPaabgabeArr[0];
|
|
|
|
if($existingPaabgabe->note !== null || $existingPaabgabe->abgabedatum !== null) {
|
|
// check if a change of paabgabetyp is being attempted -> not allowed at this point
|
|
if($paabgabetyp_kurzbz !== $existingPaabgabe->paabgabetyp_kurzbz) {
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4abgabetypAendernNichtErlaubt'));
|
|
}
|
|
|
|
|
|
// check if a change of deadline aka datum is being attempted -> should not be allowed at this point?
|
|
}
|
|
|
|
$result = $this->PaabgabeModel->update(
|
|
$paabgabe_id,
|
|
array(
|
|
'paabgabetyp_kurzbz' => $paabgabetyp_kurzbz,
|
|
'datum' => $datum,
|
|
'kurzbz' => $kurzbz,
|
|
'note' => $note,
|
|
'fixtermin' => $fixtermin,
|
|
'beurteilungsnotiz' => $beurteilungsnotiz,
|
|
'upload_allowed' => $upload_allowed,
|
|
'updatevon' => getAuthUID(),
|
|
'updateamum' => date('Y-m-d H:i:s')
|
|
)
|
|
);
|
|
|
|
$this->logLib->logInfoDB(array('paabgabe updated',$result, array(
|
|
'paabgabetyp_kurzbz' => $paabgabetyp_kurzbz,
|
|
'datum' => $datum,
|
|
'kurzbz' => $kurzbz,
|
|
'note' => $note,
|
|
'fixtermin' => $fixtermin,
|
|
'beurteilungsnotiz' => $beurteilungsnotiz,
|
|
'upload_allowed' => $upload_allowed,
|
|
'updatevon' => getAuthUID(),
|
|
'updateamum' => date('Y-m-d H:i:s')
|
|
), getAuthUID(), getAuthPersonId()));
|
|
}
|
|
|
|
// check if $paaabgabe is a qual gate and its note is deemed negative
|
|
// -> send email to student with that info
|
|
$paabgabe_id = $this->getDataOrTerminateWithError($result, 'general');
|
|
|
|
$result = $this->PaabgabeModel->load($paabgabe_id);
|
|
$paabgabeArr = $this->getDataOrTerminateWithError($result, 'general');
|
|
$paabgabe = $paabgabeArr[0];
|
|
|
|
// check if abgabe even has note
|
|
if($paabgabe->note) {
|
|
$this->load->model('education/Note_model', 'NoteModel');
|
|
$result = $this->NoteModel->load($paabgabe->note);
|
|
$noteArr = $this->getDataOrTerminateWithError($result, 'general');
|
|
$note = $noteArr[0];
|
|
if($note->positiv === false) {
|
|
|
|
if($existingPaabgabe && $existingPaabgabe->note) {
|
|
$result = $this->NoteModel->load($paabgabe->note);
|
|
$noteArr = $this->getDataOrTerminateWithError($result, 'general');
|
|
$note = $noteArr[0];
|
|
if($note->positiv === false) {
|
|
// do nothing since this means $beurteilungsnotiz change or smth else
|
|
} else { // benotung legitimately changed -> email
|
|
$this->sendQualGateNegativEmail($projektarbeit_id, $betreuer_person_id, $paabgabe);
|
|
}
|
|
} else { // nothing existing previously -> send that mail
|
|
$this->sendQualGateNegativEmail($projektarbeit_id, $betreuer_person_id, $paabgabe);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
$this->terminateWithSuccess([$paabgabe, $existingPaabgabe]);
|
|
}
|
|
|
|
/**
|
|
* called by abgabetool/assistenz when bulk-editing multiple abgabetermine via the flat termine table view
|
|
* only fields present in the payload are updated - absent fields are left untouched
|
|
*/
|
|
public function patchProjektarbeitAbgabeMultiple() {
|
|
$paabgabe_ids = $this->input->post('paabgabe_ids');
|
|
|
|
if ($paabgabe_ids === NULL || !is_array($paabgabe_ids) || count($paabgabe_ids) === 0) {
|
|
$this->terminateWithError($this->p->t('global', 'wrongParameters'), 'general');
|
|
}
|
|
|
|
// collect only fields that were actually sent
|
|
$updateFields = [];
|
|
|
|
$datum = $this->input->post('datum');
|
|
if ($datum !== NULL && trim((string)$datum) !== '') {
|
|
$updateFields['datum'] = $datum;
|
|
}
|
|
|
|
$paabgabetyp_kurzbz = $this->input->post('paabgabetyp_kurzbz');
|
|
if ($paabgabetyp_kurzbz !== NULL && trim((string)$paabgabetyp_kurzbz) !== '') {
|
|
$updateFields['paabgabetyp_kurzbz'] = $paabgabetyp_kurzbz;
|
|
}
|
|
|
|
$kurzbz = $this->input->post('kurzbz');
|
|
if ($kurzbz !== NULL) {
|
|
$updateFields['kurzbz'] = $kurzbz;
|
|
}
|
|
|
|
// booleans: only include if explicitly posted
|
|
$upload_allowed = $this->input->post('upload_allowed');
|
|
if ($upload_allowed !== NULL) {
|
|
$updateFields['upload_allowed'] = filter_var($upload_allowed, FILTER_VALIDATE_BOOLEAN);
|
|
}
|
|
|
|
$fixtermin = $this->input->post('fixtermin');
|
|
if ($fixtermin !== NULL) {
|
|
$updateFields['fixtermin'] = filter_var($fixtermin, FILTER_VALIDATE_BOOLEAN);
|
|
}
|
|
|
|
if (empty($updateFields)) {
|
|
$this->terminateWithError($this->p->t('global', 'wrongParameters'), 'general');
|
|
}
|
|
|
|
$this->load->model('education/Paabgabe_model', 'PaabgabeModel');
|
|
|
|
$results = [];
|
|
foreach ($paabgabe_ids as $paabgabe_id) {
|
|
$paabgabe_id = trim((string)$paabgabe_id);
|
|
|
|
if ($paabgabe_id === '') {
|
|
$this->terminateWithError($this->p->t('global', 'wrongParameters'), 'general');
|
|
}
|
|
|
|
$projektarbeit_id = $this->getProjektarbeitIDForPaabgabeID($paabgabe_id);
|
|
|
|
$this->checkProjektarbeitForFinishedStatus($projektarbeit_id);
|
|
|
|
$zugeordnet = $this->checkZuordnung($projektarbeit_id, getAuthUID());
|
|
if (!$zugeordnet) {
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4noZuordnungBetreuerStudent'), 'general');
|
|
}
|
|
|
|
$paabgabeResult = $this->PaabgabeModel->load($paabgabe_id);
|
|
$paabgabeArr = $this->getDataOrTerminateWithError($paabgabeResult, 'general');
|
|
|
|
if (count($paabgabeArr) === 0) {
|
|
$this->terminateWithError($this->p->t('global', 'wrongParameters'), 'general');
|
|
}
|
|
|
|
$result = $this->PaabgabeModel->update(
|
|
$paabgabe_id,
|
|
array_merge($updateFields, [
|
|
'updatevon' => getAuthUID(),
|
|
'updateamum' => date('Y-m-d H:i:s')
|
|
])
|
|
);
|
|
|
|
$this->getDataOrTerminateWithError($result, 'general');
|
|
$results[] = getData($this->PaabgabeModel->load($paabgabe_id))[0];
|
|
|
|
$this->logLib->logInfoDB(array(
|
|
'paabgabe bulk updated',
|
|
$paabgabe_id,
|
|
$updateFields,
|
|
getAuthUID(),
|
|
getAuthPersonId()
|
|
));
|
|
}
|
|
|
|
$this->terminateWithSuccess($results);
|
|
}
|
|
|
|
/**
|
|
* called by abgabetool/mitarbeiter in mitarbeiterdetail.js when deleting an abgabetermin
|
|
* deletion is only possible if user is assistenz OR betreuer deletes their own custom termin
|
|
* none of these roles are allowed to delete if students uploaded something for that termin
|
|
*/
|
|
public function deleteProjektarbeitAbgabe() {
|
|
$paabgabe_id = $this->input->post('paabgabe_id');
|
|
|
|
if ($paabgabe_id === NULL || trim((string)$paabgabe_id) === '') {
|
|
$this->terminateWithError($this->p->t('global', 'wrongParameters'), 'general');
|
|
}
|
|
|
|
$this->checkProjektarbeitForFinishedStatus($this->getProjektarbeitIDForPaabgabeID($paabgabe_id));
|
|
|
|
$zugeordnet = $this->checkZuordnungByPaabgabe($paabgabe_id, getAuthUID());
|
|
|
|
if(!$zugeordnet) {
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4noZuordnungBetreuerStudent'), 'general');
|
|
}
|
|
|
|
$this->load->model('education/Paabgabe_model', 'PaabgabeModel');
|
|
|
|
$paabgabeResult = $this->PaabgabeModel->load($paabgabe_id);
|
|
$paabgabeArr = $this->getDataOrTerminateWithError($paabgabeResult, 'general');
|
|
|
|
if(count($paabgabeArr) == 0) {
|
|
$this->terminateWithError($this->p->t('global', 'wrongParameters'), 'general');
|
|
}
|
|
|
|
$result = $this->PaabgabeModel->delete($paabgabe_id);
|
|
$result = $this->getDataOrTerminateWithError($result, 'general');
|
|
|
|
$this->logLib->logInfoDB(array($paabgabeArr[0], getAuthUID(), getAuthPersonId()));
|
|
$this->terminateWithSuccess($result);
|
|
}
|
|
|
|
/**
|
|
* called by abgabetool/assistenz when deleting multiple abgabetermine via the flat termine table view
|
|
*/
|
|
public function deleteProjektarbeitAbgabeMultiple() {
|
|
$paabgabe_ids = $this->input->post('paabgabe_ids');
|
|
|
|
if ($paabgabe_ids === NULL || !is_array($paabgabe_ids) || count($paabgabe_ids) === 0) {
|
|
$this->terminateWithError($this->p->t('global', 'wrongParameters'), 'general');
|
|
}
|
|
|
|
$this->load->model('education/Paabgabe_model', 'PaabgabeModel');
|
|
|
|
$results = [];
|
|
foreach ($paabgabe_ids as $paabgabe_id) {
|
|
$paabgabe_id = trim((string)$paabgabe_id);
|
|
|
|
if ($paabgabe_id === '') {
|
|
$this->terminateWithError($this->p->t('global', 'wrongParameters'), 'general');
|
|
}
|
|
|
|
$this->checkProjektarbeitForFinishedStatus($this->getProjektarbeitIDForPaabgabeID($paabgabe_id));
|
|
|
|
$zugeordnet = $this->checkZuordnungByPaabgabe($paabgabe_id, getAuthUID());
|
|
|
|
if (!$zugeordnet) {
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4noZuordnungBetreuerStudent'), 'general');
|
|
}
|
|
|
|
$paabgabeResult = $this->PaabgabeModel->load($paabgabe_id);
|
|
$paabgabeArr = $this->getDataOrTerminateWithError($paabgabeResult, 'general');
|
|
|
|
if (count($paabgabeArr) == 0) {
|
|
$this->terminateWithError($this->p->t('global', 'wrongParameters'), 'general');
|
|
}
|
|
|
|
$result = $this->PaabgabeModel->delete($paabgabe_id);
|
|
$result = $this->getDataOrTerminateWithError($result, 'general');
|
|
$results[] = $result;
|
|
|
|
$this->logLib->logInfoDB(array($paabgabeArr[0], getAuthUID(), getAuthPersonId()));
|
|
}
|
|
|
|
$this->terminateWithSuccess($results);
|
|
}
|
|
|
|
/**
|
|
* endpoint for adding the same paabgabe for multiple projektarbeiten
|
|
* can be slow for large n since it queries twice per projektarbeit_id
|
|
*/
|
|
public function postSerientermin() {
|
|
$projektarbeit_ids = $this->input->post('projektarbeit_ids');
|
|
$datum = $this->input->post('datum');
|
|
$paabgabetyp_kurzbz = $this->input->post('paabgabetyp_kurzbz');
|
|
$bezeichnung = $this->input->post('bezeichnung');
|
|
$kurzbz = $this->input->post('kurzbz');
|
|
$fixtermin = $this->input->post('fixtermin');
|
|
$upload_allowed = $this->input->post('upload_allowed');
|
|
|
|
if ($projektarbeit_ids === NULL || !is_array($projektarbeit_ids) || empty($projektarbeit_ids)
|
|
|| $datum === NULL || trim((string)$datum) === ''
|
|
|| $kurzbz === NULL
|
|
|| $bezeichnung === NULL || trim((string)$bezeichnung) === ''
|
|
|| $paabgabetyp_kurzbz === NULL || trim((string)$paabgabetyp_kurzbz) === '') {
|
|
$this->terminateWithError($this->p->t('global', 'wrongParameters'), 'general');
|
|
}
|
|
|
|
// old script checks if there already are tbl_paabgabe entries with exact date, type & kurzbz
|
|
// for each termin - good to check that in principle but should not matter in this place. if necessary
|
|
// duplicate abgabetermine can be easily deleted manually, also via cronjob@night.
|
|
|
|
// since this entry includes the kurzbz string match, it should have only ever mattered when there were
|
|
// multiple users entering the exact same set of (date, type, kurzbz) - which is a much more narrow case than the
|
|
// general "saveMultiple" function should handle
|
|
|
|
// old script afterwards again queries if user is not the zweitbetreuer of any id - this is blocked in the ui
|
|
// and should never unintentionally happen
|
|
$this->load->model('education/Paabgabe_model', 'PaabgabeModel');
|
|
$this->load->model('education/Projektarbeit_model', 'ProjektarbeitModel');
|
|
|
|
$res = [];
|
|
$abgaben = [];
|
|
foreach ($projektarbeit_ids as $projektarbeit_id) {
|
|
|
|
$this->checkProjektarbeitForFinishedStatus($projektarbeit_id);
|
|
|
|
$zugeordnet = $this->checkZuordnung($projektarbeit_id, getAuthUID());
|
|
if(!$zugeordnet) {
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4noZuordnungBetreuerStudent'), 'general');
|
|
}
|
|
|
|
$result = $this->PaabgabeModel->insert(
|
|
array(
|
|
'projektarbeit_id' => $projektarbeit_id,
|
|
'paabgabetyp_kurzbz' => $paabgabetyp_kurzbz,
|
|
'fixtermin' => $fixtermin,
|
|
'datum' => $datum,
|
|
'kurzbz' => $kurzbz,
|
|
'upload_allowed' => $upload_allowed,
|
|
'insertvon' => getAuthUID(),
|
|
'insertamum' => date('Y-m-d H:i:s')
|
|
)
|
|
);
|
|
|
|
$dataAbgabe = $this->getDataOrTerminateWithError($result, 'general');
|
|
|
|
$abgaben[]= getData($this->PaabgabeModel->load($dataAbgabe))[0];
|
|
}
|
|
|
|
$this->logLib->logInfoDB(array('serientermin angelegt',array(
|
|
'projektarbeit_id' => $projektarbeit_id,
|
|
'paabgabetyp_kurzbz' => $paabgabetyp_kurzbz,
|
|
'fixtermin' => $fixtermin,
|
|
'datum' => $datum,
|
|
'kurzbz' => $kurzbz,
|
|
'upload_allowed' => $upload_allowed,
|
|
'insertvon' => getAuthUID(),
|
|
'insertamum' => date('Y-m-d H:i:s')
|
|
), getAuthUID(), getAuthPersonId()));
|
|
|
|
$this->terminateWithSuccess($abgaben);
|
|
}
|
|
|
|
/**
|
|
* called by Abgabetool/Deadlines
|
|
* fetches the next upcoming abgabtermine for a given betreuer person_id
|
|
* resembles the legacy abgabetool functionality of "show deadlines"
|
|
*/
|
|
public function fetchDeadlines() {
|
|
$person_id = $this->input->post('person_id');
|
|
|
|
if ($person_id === NULL || trim((string)$person_id) === '') {
|
|
$person_id = getAuthPersonId();
|
|
}
|
|
|
|
if($person_id !== getAuthPersonId()) {
|
|
$this->load->library('PermissionLib');
|
|
$isAdmin = $this->permissionlib->isBerechtigt('admin');
|
|
if(!$isAdmin) $this->terminateWithError($this->p->t('ui', 'keineBerechtigung'), 'general');
|
|
}
|
|
|
|
$this->load->model('education/Paabgabe_model', 'PaabgabeModel');
|
|
$result = $this->PaabgabeModel->getDeadlines($person_id);
|
|
$data = $this->getDataOrTerminateWithError($result, 'general');
|
|
|
|
$this->terminateWithSuccess($data);
|
|
}
|
|
|
|
/**
|
|
* called by Abgabetool/Mitarbeiter & Abgabetool/Assistenz
|
|
* fetches all available paabgabetypen to enable a logical selection of them
|
|
* based on active status and role assistenz/betreuer
|
|
*/
|
|
public function getPaAbgabetypen() {
|
|
$this->load->model('education/Paabgabetyp_model', 'PaabgabetypModel');
|
|
|
|
$result = $this->PaabgabetypModel->getAll();
|
|
$paabgabetypen = $this->getDataOrTerminateWithError($result, 'general');
|
|
|
|
|
|
$this->terminateWithSuccess($paabgabetypen);
|
|
}
|
|
|
|
/**
|
|
* helper function to fetch the correct email for a projektarbeits erstbetreuer
|
|
*/
|
|
private function getProjektbetreuerEmailByProjektarbeitID($projektarbeit_id) {
|
|
$this->load->model('education/Projektarbeit_model', 'ProjektarbeitModel');
|
|
$result = $this->ProjektarbeitModel->getProjektbetreuerEmail($projektarbeit_id);
|
|
if(count($result->retval) > 0) {
|
|
$email = getData($result);
|
|
return $email[0]->uid ? $email[0]->uid.'@'.DOMAIN : $email[0]->private_email;
|
|
} else return '';
|
|
|
|
}
|
|
|
|
/**
|
|
* helper function to fetch the correct email for a projektarbeits zweitbetreuer by their person id
|
|
* can be used for erstbetreuer aswell if necessary
|
|
*/
|
|
private function getProjektbetreuerEmailByPersonID($person_id) {
|
|
$this->load->model('education/Projektarbeit_model', 'ProjektarbeitModel');
|
|
$result = $this->ProjektarbeitModel->getProjektbetreuerEmailByPersonID($person_id);
|
|
$email = $this->getDataOrTerminateWithError($result, 'general');
|
|
|
|
return $email[0]->uid ? $email[0]->uid.'@'.DOMAIN : $email[0]->private_email;
|
|
}
|
|
|
|
//TODO: SWITCH TO NOTEN API ONCE NOTENTOOL IS IN MASTER TO AVOID DUPLICATE API
|
|
|
|
/**
|
|
* GET METHOD
|
|
* returns List of all available & active NotenOptions
|
|
*/
|
|
public function getNoten() {
|
|
$this->load->model('education/Note_model', 'NoteModel');
|
|
|
|
$result = $this->NoteModel->getAllActive();
|
|
$noten = $this->getDataOrTerminateWithError($result, 'general');
|
|
|
|
$allowed_noten_abgabetool = $this->config->item('ALLOWED_NOTEN_ABGABETOOL');
|
|
|
|
$nonfinal_noten_abgabetool = $this->config->item('NONFINAL_NOTEN_ABGABETOOL');
|
|
|
|
|
|
$this->terminateWithSuccess(array($noten, $allowed_noten_abgabetool, $nonfinal_noten_abgabetool));
|
|
}
|
|
|
|
/**
|
|
* helper function to send a sancho mail to students if a betreuer or assistenz grades a quality gate
|
|
* termin as negative (nicht bestanden)
|
|
*/
|
|
private function sendQualGateNegativEmail($projektarbeit_id, $betreuer_person_id, $paabgabe) {
|
|
$this->load->model('education/Projektarbeit_model', 'ProjektarbeitModel');
|
|
|
|
$result = $this->ProjektarbeitModel->load($projektarbeit_id);
|
|
$projektarbeitArr = $this->getDataOrTerminateWithError($result, 'general');
|
|
$projektarbeit = $projektarbeitArr[0];
|
|
|
|
$result = $this->ProjektarbeitModel->getProjektbetreuerAnrede($betreuer_person_id);
|
|
$anredeArr = $this->getDataOrTerminateWithError($result, 'general');
|
|
$anrede = $anredeArr[0];
|
|
|
|
$student_uid = $projektarbeit->student_uid;
|
|
|
|
$this->load->model('education/Paabgabetyp_model', 'PaabgabetypModel');
|
|
$result = $this->PaabgabetypModel->load($paabgabe->paabgabetyp_kurzbz);
|
|
$paabgabetyp_kurzbzArr = $this->getDataOrTerminateWithError($result, 'general');
|
|
$paabgabetyp_kurzbz = $paabgabetyp_kurzbzArr[0];
|
|
|
|
// Mail an Student wenn Qualgate negativ beurteilt wurde
|
|
$this->load->model('crm/Student_model', 'StudentModel');
|
|
$result = $this->StudentModel->load([$student_uid]);
|
|
$studentArr = $this->getDataOrTerminateWithError($result, 'general');
|
|
$student = $studentArr[0];
|
|
|
|
if(!$student) {
|
|
$this->terminateWithError($this->p->t('abgabetool','c4userNichtGefunden'), 'general');
|
|
}
|
|
|
|
$subject = $this->p->t('abgabetool', 'c4qualgateNegativEmailSubjectv2');
|
|
$tomail = $student_uid.'@'.DOMAIN;
|
|
|
|
$datetime = new DateTime($paabgabe->datum);
|
|
$dateEmailFormatted = $datetime->format('d.m.Y');
|
|
|
|
$data = array(
|
|
'betreuerfullname' => $anrede->first,
|
|
'qualgatebezeichnung' => $paabgabetyp_kurzbz->bezeichnung,
|
|
'datum' => $dateEmailFormatted,
|
|
'projektarbeitname' => $projektarbeit->titel
|
|
);
|
|
|
|
// students still get theirs on event, since it is very unlikely that this
|
|
// leads to spam on their end
|
|
|
|
$mailres = sendSanchoMail(
|
|
'QualGateNegativ',
|
|
$data,
|
|
$tomail,
|
|
$subject
|
|
);
|
|
|
|
}
|
|
|
|
/**
|
|
* tabulator tabledata fetch for abgabetool/assistenz
|
|
* initially fetches all ungraded projektarbeiten with all their abgabetermine
|
|
*/
|
|
public function getProjektarbeitenForStudiengang() {
|
|
$this->load->model('education/Projektarbeit_model', 'ProjektarbeitModel');
|
|
|
|
$studiengang_kz = $this->input->get("studiengang_kz", TRUE);
|
|
$benotet = $this->input->get("benotet", TRUE);
|
|
|
|
if ($studiengang_kz === NULL || trim((string)$studiengang_kz) === '') {
|
|
$this->terminateWithError($this->p->t('global', 'wrongParameters'), 'general');
|
|
}
|
|
|
|
// TODO: recheck getSTGEntitlement here!
|
|
$stg_allowed = $this->permissionlib->getSTG_isEntitledFor('basis/abgabe_assistenz:rw');
|
|
if($stg_allowed == false) {
|
|
$this->terminateWithError($this->p->t('ui', 'keineBerechtigung'), 'general');
|
|
}
|
|
|
|
// check if provided studiengang_kz is included in stg_allowed to proceed
|
|
if(!in_array($studiengang_kz, $stg_allowed)) {
|
|
$this->terminateWithError($this->p->t('ui', 'keineBerechtigung'), 'general');
|
|
}
|
|
|
|
$result = $this->ProjektarbeitModel->getProjektarbeitenForStudiengang($studiengang_kz, $benotet);
|
|
$projektarbeiten = $this->getDataOrTerminateWithError($result, 'general');
|
|
|
|
if(count($projektarbeiten) == 0) { // avoid further abgabetermin queries if the are no projektarbeiten
|
|
$this->terminateWithSuccess(array($projektarbeiten, DOMAIN));
|
|
}
|
|
|
|
$mapFunc = function($projektarbeit) {
|
|
return $projektarbeit->projektarbeit_id;
|
|
};
|
|
$projektarbeiten_ids = array_map($mapFunc, $projektarbeiten);
|
|
|
|
$ret = $this->ProjektarbeitModel->getProjektarbeitenAbgabetermine($projektarbeiten_ids);
|
|
$projektabgaben = $this->getDataOrTerminateWithError($ret, 'general');
|
|
|
|
// map the abgaben into projektarbeiten
|
|
foreach($projektarbeiten as $projektarbeit) {
|
|
$projektarbeit->betreuer_mail = $this->getProjektbetreuerEmailByProjektarbeitID($projektarbeit->projektarbeit_id);
|
|
|
|
if($projektarbeit->zweitbetreuer_person_id !== null) {
|
|
$projektarbeit->zweitbetreuer_mail = $this->getProjektbetreuerEmailByPersonID($projektarbeit->zweitbetreuer_person_id);
|
|
}
|
|
|
|
$filterFunc = function($projektabgabe) use ($projektarbeit) {
|
|
return $projektabgabe->projektarbeit_id == $projektarbeit->projektarbeit_id;
|
|
};
|
|
|
|
$projektarbeit->abgabetermine = array_values(array_filter($projektabgaben, $filterFunc));
|
|
}
|
|
|
|
$this->terminateWithSuccess(array($projektarbeiten, DOMAIN));
|
|
}
|
|
|
|
// TODO: this could be in a generic info controller and reused
|
|
/**
|
|
* GET METHOD
|
|
* returns List of all studiengang_kz a user has the assigned permission 'basis/abgabe_assistenz:rw' for
|
|
* used in Abgabetool/Assistenz to populate Studiengang Dropdown
|
|
*/
|
|
public function getStudiengaenge() {
|
|
$this->load->library('PermissionLib');
|
|
|
|
$stg_allowed = $this->permissionlib->getSTG_isEntitledFor('basis/abgabe_assistenz:rw');
|
|
|
|
if($stg_allowed == false) {
|
|
$this->terminateWithError($this->p->t('ui', 'keineBerechtigung'), 'general');
|
|
}
|
|
|
|
$this->load->model('organisation/Studiengang_model', 'StudiengangModel');
|
|
|
|
$result = $this->StudiengangModel->getStudiengaengeFiltered($stg_allowed);
|
|
$data = $this->getDataOrTerminateWithError($result, 'general');
|
|
|
|
$this->terminateWithSuccess($data);
|
|
}
|
|
|
|
/**
|
|
* GET METHOD
|
|
* endpoint to download the abgabe of a paabgabe termin zwischenabgabe or endupload
|
|
*/
|
|
public function getStudentProjektarbeitAbgabeFile()
|
|
{
|
|
$this->load->helper('download');
|
|
|
|
$projektarbeit_id = $this->input->get('projektarbeit_id');
|
|
$paabgabe_id = $this->input->get('paabgabe_id');
|
|
$student_uid = $this->input->get('student_uid');
|
|
|
|
if ($paabgabe_id === NULL || trim((string)$paabgabe_id) === ''
|
|
|| $projektarbeit_id === NULL || trim((string)$projektarbeit_id) === ''
|
|
|| $student_uid === NULL || trim((string)$student_uid) === '') {
|
|
$this->terminateWithError($this->p->t('global', 'wrongParameters'), 'general');
|
|
}
|
|
|
|
$this->load->model('education/Projektarbeit_model', 'ProjektarbeitModel');
|
|
|
|
// zuordnung function is supposed for mitarbeiter_uids, students should be allowed to download their own files
|
|
// without adapting zuordnung logic
|
|
$zugeordnet = $this->checkZuordnung($projektarbeit_id, getAuthUID());
|
|
if(getAuthUID() == $student_uid || $zugeordnet) {
|
|
$file_path = PAABGABE_PATH.$paabgabe_id.'_'.$student_uid.'.pdf';
|
|
|
|
|
|
if(file_exists($file_path)) {
|
|
$this->terminateWithFileOutput('application/octet-stream', file_get_contents($file_path), basename($file_path));
|
|
} else {
|
|
$this->terminateWithError('File not found', 'general');
|
|
}
|
|
} else {
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4noZuordnungBetreuerStudent'), 'general');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* POST METHOD
|
|
* endpoint to enable Assistenz/Betreuer to edit the zusatzdate of a projektarbeit, in case the student somehow
|
|
* can't do it themself
|
|
*/
|
|
public function postStudentProjektarbeitZusatzdaten(){
|
|
$projektarbeit_id = $this->input->post('projektarbeit_id');
|
|
$sprache = $this->input->post('sprache');
|
|
$abstract = $this->input->post('abstract');
|
|
$abstract_en = $this->input->post('abstract_en');
|
|
$schlagwoerter = $this->input->post('schlagwoerter');
|
|
$schlagwoerter_en = $this->input->post('schlagwoerter_en');
|
|
$seitenanzahl = $this->input->post('seitenanzahl');
|
|
|
|
if ($projektarbeit_id === NULL || trim((string)$projektarbeit_id) === ''
|
|
|| $sprache === NULL || trim((string)$sprache) === ''
|
|
|| $seitenanzahl === NULL || trim((string)$seitenanzahl) === ''
|
|
|| $abstract === NULL || trim((string)$abstract) === ''
|
|
|| $abstract_en === NULL || trim((string)$abstract_en) === ''
|
|
|| $schlagwoerter === NULL || trim((string)$schlagwoerter) === ''
|
|
|| $schlagwoerter_en === NULL || trim((string)$schlagwoerter_en) === '') {
|
|
|
|
$this->terminateWithError($this->p->t('global', 'wrongParameters'), 'general');
|
|
}
|
|
|
|
$this->load->model('education/Projektarbeit_model', 'ProjektarbeitModel');
|
|
|
|
|
|
|
|
$result = $this->ProjektarbeitModel->load($projektarbeit_id);
|
|
$projektarbeitArr = $this->getDataOrTerminateWithError($result, 'general');
|
|
|
|
if(count($projektarbeitArr) > 0) {
|
|
$projektarbeit = $projektarbeitArr[0];
|
|
} else {
|
|
$this->terminateWithError($this->p->t('abgabetool','c4projektarbeitNichtGefunden'), 'general');
|
|
}
|
|
|
|
$this->checkProjektarbeitForFinishedStatus($projektarbeit_id);
|
|
|
|
$zugeordnet = $this->checkZuordnung($projektarbeit_id, getAuthUID());
|
|
if(!$zugeordnet) {
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4noZuordnungBetreuerStudent'), 'general');
|
|
}
|
|
|
|
// update projektarbeit cols with zusatzdaten only
|
|
$this->ProjektarbeitModel->update($projektarbeit_id, array(
|
|
'sprache' => $sprache,
|
|
'seitenanzahl' => $seitenanzahl,
|
|
'schlagwoerter_en' => $schlagwoerter_en,
|
|
'schlagwoerter' => $schlagwoerter,
|
|
'abstract' => $abstract,
|
|
'abstract_en' => $abstract_en
|
|
));
|
|
|
|
$this->logLib->logInfoDB(array('zusatzdatenEditMitarbeiter', array(
|
|
'updatevon' => getAuthUID(),
|
|
'updateamum' => date('Y-m-d H:i:s')
|
|
), getAuthUID(), getAuthPersonId(), array($projektarbeit_id,$sprache,$abstract,$abstract_en
|
|
,$schlagwoerter, $schlagwoerter_en, $seitenanzahl)));
|
|
|
|
$result = $this->ProjektarbeitModel->load($projektarbeit_id);
|
|
|
|
$this->terminateWithSuccess($result);
|
|
}
|
|
|
|
// used to lazy load signatur status for assistenzen, since they could run into very long fetch times
|
|
// since they fetch the projektarbeiten with paabgaben included and could have a lot of huge endupload files
|
|
// in their stg resulting in huge loading times -> use this api call on opening detail component instead
|
|
public function getSignaturStatusForProjektarbeitAbgaben() {
|
|
$paabgabe_ids = $this->input->post('paabgabe_ids');
|
|
$student_uid = $this->input->post('student_uid');
|
|
|
|
if ($paabgabe_ids === NULL || $student_uid === NULL || trim((string)$student_uid) === '') {
|
|
$this->terminateWithError($this->p->t('global', 'wrongParameters'), 'general');
|
|
}
|
|
|
|
$this->load->model('education/Paabgabe_model', 'PaabgabeModel');
|
|
|
|
$result = $this->PaabgabeModel->loadByIDs($paabgabe_ids);
|
|
$data = $this->getDataOrTerminateWithError($result);
|
|
|
|
foreach($data as $paabgabetermin) {
|
|
$this->checkAbgabeSignatur($paabgabetermin, $student_uid);
|
|
}
|
|
|
|
$this->terminateWithSuccess($data);
|
|
}
|
|
|
|
/**
|
|
* helper function to check the signature status of uploaded files for zwischenabgabe & endupload
|
|
*/
|
|
private function checkAbgabeSignatur($abgabe, $student_uid) {
|
|
$paabgabetypenToCheck = $this->config->item('SIGNATUR_CHECK_PAABGABETYPEN');
|
|
|
|
if(!in_array($abgabe->paabgabetyp_kurzbz, $paabgabetypenToCheck)) {
|
|
return;
|
|
}
|
|
|
|
if (!defined('SIGNATUR_URL')) {
|
|
$abgabe->signatur = 'error';
|
|
return;
|
|
}
|
|
|
|
$path = PAABGABE_PATH.$abgabe->paabgabe_id.'_'.$student_uid.'.pdf';
|
|
|
|
$signaturVorhanden = null; // if frontend receives null -> indicates no file found at path
|
|
if(file_exists($path)) {
|
|
|
|
// Check if the document is signed
|
|
$signList = SignatureLib::list($path);
|
|
if (is_array($signList) && count($signList) > 0)
|
|
{
|
|
// The document is signed
|
|
$signaturVorhanden = true;
|
|
}
|
|
elseif ($signList === null)
|
|
{
|
|
// frontend knows to handle it this way for signatures
|
|
$signaturVorhanden = 'error';
|
|
}
|
|
else
|
|
{
|
|
$signaturVorhanden = false;
|
|
}
|
|
|
|
$abgabe->signatur = $signaturVorhanden;
|
|
}
|
|
}
|
|
|
|
private function sendUploadEmail($bperson_id, $projektarbeit_id, $paabgabetyp_kurzbz, $student_uid) {
|
|
$this->load->model('education/Projektarbeit_model', 'ProjektarbeitModel');
|
|
|
|
$resBetr = $this->ProjektarbeitModel->getProjektbetreuerAnrede($bperson_id);
|
|
|
|
|
|
$result = $this->ProjektarbeitModel->load($projektarbeit_id);
|
|
$projektarbeitArr = $this->getDataOrTerminateWithError($result, 'general');
|
|
|
|
if(count($projektarbeitArr) > 0) {
|
|
$projektarbeit = $projektarbeitArr[0];
|
|
} else {
|
|
$this->terminateWithError($this->p->t('abgabetool','c4projektarbeitNichtGefunden'), 'general');
|
|
}
|
|
|
|
$projektarbeitIsCurrent = false;
|
|
$returnFunc = function ($result) use (&$projektarbeitIsCurrent) {
|
|
$projektarbeitIsCurrent = $result;
|
|
};
|
|
Events::trigger('projektarbeit_is_current', $projektarbeit_id, $returnFunc);
|
|
if(!$projektarbeitIsCurrent) {
|
|
$this->terminateWithError($this->p->t('abgabetool','c4fehlerAktualitaetProjektarbeitv2'), 'general');
|
|
}
|
|
|
|
// Link to Abgabetool
|
|
if (defined('CIS4') && CIS4) {
|
|
$ci3BootstrapFilePath = "cis.php";
|
|
} else {
|
|
$ci3BootstrapFilePath = "index.ci.php";
|
|
}
|
|
|
|
$path = $this->config->item('URL_MITARBEITER');
|
|
$url = APP_ROOT.$path;
|
|
|
|
// getProjektbetreuerAnrede fetches distinct on person_id, so there should be one row. zweitbetreuer is handled seperately afterwards
|
|
foreach($resBetr->retval as $betreuerRow) {
|
|
|
|
// query student benutzer view for every betreuer row
|
|
$studentUser = $this->ProjektarbeitModel->getProjektarbeitBenutzer($student_uid)->retval[0];
|
|
|
|
// 1. Begutachter mail ohne Token
|
|
$mail_baselink = APP_ROOT.$this->config->item('PROJEKTARBEITSBEURTEILUNG_MAIL_BASELINK_ERSTBEGUTACHTER');
|
|
// $mail_baselink = APP_ROOT."index.ci.php/extensions/FHC-Core-Projektarbeitsbeurteilung/ProjektarbeitsbeurteilungErstbegutachter";
|
|
$mail_fulllink = "$mail_baselink?projektarbeit_id=".$projektarbeit_id."&uid=".$studentUser->uid;
|
|
$projekttyp_kurzbz = $projektarbeit->projekttyp_kurzbz;
|
|
$subject = $projektarbeit->projekttyp_kurzbz == 'Diplom' ? 'Masterarbeitsbetreuung' : 'Bachelorarbeitsbetreuung';
|
|
$abgabetyp = $paabgabetyp_kurzbz == 'end' ? 'Endabgabe' : 'Zwischenabgabe';
|
|
|
|
$maildata = array();
|
|
$maildata['geehrt'] = "geehrte".($betreuerRow->anrede=="Herr"?"r":"");
|
|
$maildata['anrede'] = $betreuerRow->anrede;
|
|
$maildata['betreuer_voller_name'] = $betreuerRow->first;
|
|
$maildata['student_anrede'] = $studentUser->anrede;
|
|
$maildata['student_voller_name'] = trim($studentUser->titelpre." ".$studentUser->vorname." ".$studentUser->nachname." ".$studentUser->titelpost);
|
|
$maildata['abgabetyp'] = $abgabetyp;
|
|
$maildata['parbeituebersichtlink'] = "<p><a href='$url'>Zur Projektarbeitsübersicht</a></p>";
|
|
$maildata['bewertunglink'] = $projektarbeitIsCurrent && $paabgabetyp_kurzbz == 'end' ? "<p><a href='$mail_fulllink'>Zur Beurteilung der Arbeit</a></p>" : "";
|
|
$maildata['token'] = "";
|
|
|
|
$email = $this->getProjektbetreuerEmailByProjektarbeitID($projektarbeit_id);
|
|
|
|
if(!$email) $this->terminateWithError($this->p->t('abgabetool', 'c4fehlerMailBegutachterv2'), 'general');
|
|
|
|
$mailres = sendSanchoMail(
|
|
'ParbeitsbeurteilungEndupload',
|
|
$maildata,
|
|
$email,
|
|
$subject,
|
|
'sancho_header_min_bw.jpg',
|
|
'sancho_footer_min_bw.jpg',
|
|
get_uid()."@".DOMAIN);
|
|
|
|
if(!$mailres)
|
|
{
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4fehlerMailBegutachterv2'), 'general');
|
|
}
|
|
|
|
// 2. Begutachter mail, wenn Endabgabe, mit Token wenn extern
|
|
if ($paabgabetyp_kurzbz == 'end')
|
|
{
|
|
// Zweitbegutachter holen
|
|
$this->load->model('education/Projektbetreuer_model', 'ProjektbetreuerModel');
|
|
$zweitbegutachterRetval = getData($this->ProjektbetreuerModel->getZweitbegutachterWithToken($bperson_id, $projektarbeit_id, $studentUser->uid));
|
|
|
|
if ($zweitbegutachterRetval && count($zweitbegutachterRetval) > 0)
|
|
{
|
|
|
|
foreach ($zweitbegutachterRetval as $begutachter)
|
|
{
|
|
// token generieren, wenn noch nicht vorhanden und notwendig (wird in methode überprüft)
|
|
$tokenGenRes = $this->ProjektbetreuerModel->generateZweitbegutachterToken($begutachter->person_id, $projektarbeit_id);
|
|
|
|
if (!$tokenGenRes)
|
|
{
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4fehlerMailZweitBegutachterv2'), 'general');
|
|
}
|
|
|
|
$begutachterMitTokenRetval = getData($this->ProjektbetreuerModel->getZweitbegutachterWithToken($bperson_id, $projektarbeit_id, $studentUser->uid, $begutachter->person_id));
|
|
|
|
if (!$begutachterMitTokenRetval && count($begutachterMitTokenRetval) <= 0)
|
|
{
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4fehlerMailZweitBegutachterv2'), 'general');
|
|
}
|
|
|
|
$begutachterMitToken = $begutachterMitTokenRetval[0];
|
|
|
|
$path = $begutachterMitToken->betreuerart_kurzbz == 'Zweitbegutachter' ? 'ProjektarbeitsbeurteilungZweitbegutachter' : 'ProjektarbeitsbeurteilungErstbegutachter';
|
|
$mail_baselink = APP_ROOT."index.ci.php/extensions/FHC-Core-Projektarbeitsbeurteilung/$path";
|
|
$mail_fulllink = "$mail_baselink?projektarbeit_id=".$projektarbeit_id."&uid=".$studentUser->uid;
|
|
$intern = isset($begutachterMitToken->uid);
|
|
$mail_link = $intern ? $mail_fulllink : $mail_baselink;
|
|
|
|
$zweitbetmaildata = array();
|
|
$zweitbetmaildata['geehrt'] = "geehrte" . ($begutachterMitToken->anrede == "Herr" ? "r" : "");
|
|
$zweitbetmaildata['anrede'] = $begutachterMitToken->anrede;
|
|
$zweitbetmaildata['betreuer_voller_name'] = $begutachterMitToken->voller_name;
|
|
$zweitbetmaildata['student_anrede'] = $maildata['student_anrede'];
|
|
$zweitbetmaildata['student_voller_name'] = $maildata['student_voller_name'];
|
|
$zweitbetmaildata['abgabetyp'] = $abgabetyp;
|
|
$zweitbetmaildata['parbeituebersichtlink'] = $intern ? $maildata['parbeituebersichtlink'] : "";
|
|
$zweitbetmaildata['bewertunglink'] = $projektarbeitIsCurrent ? "<p><a href='$mail_link'>Zur Beurteilung der Arbeit</a></p>" : "";
|
|
$zweitbetmaildata['token'] = $projektarbeitIsCurrent && isset($begutachterMitToken->zugangstoken) && !$intern ? "<p>Zugangstoken: " . $begutachterMitToken->zugangstoken . "</p>" : "";
|
|
|
|
$mailres = sendSanchoMail(
|
|
'ParbeitsbeurteilungEndupload',
|
|
$zweitbetmaildata,
|
|
$begutachterMitToken->email,
|
|
$subject,
|
|
'sancho_header_min_bw.jpg',
|
|
'sancho_footer_min_bw.jpg',
|
|
get_uid()."@".DOMAIN
|
|
);
|
|
|
|
if (!$mailres)
|
|
{
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4fehlerMailBegutachterv2'), 'general');
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private function checkZuordnung($projektarbeit_id, $betreuer_uid) {
|
|
// check if authenticated user is zugewiesen as betreuer to projektarbeit or has admin/assistenz berechtigung
|
|
// over the studiengang of the student working on that projektarbeit_id
|
|
|
|
$this->load->model('education/Projektarbeit_model', 'ProjektarbeitModel');
|
|
|
|
$res = $this->ProjektarbeitModel->getStudentInfoForProjektarbeitId($projektarbeit_id);
|
|
if(isError($res)) {
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4errorLoadingStudentForProjektarbeitID'), 'general');
|
|
}
|
|
|
|
if(!hasData($res)) {
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4noAssignedStudentForProjektarbeitID'), 'general');
|
|
}
|
|
$data = getData($res)[0];
|
|
$student_uid = $data->uid;
|
|
$studiengang_kz = $data->studiengang_kz;
|
|
|
|
$res = $this->ProjektarbeitModel->checkZuordnung($student_uid, $betreuer_uid);
|
|
if(isError($res)) {
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4errorLoadingBetreuerStudentZuordnung'), 'general');
|
|
}
|
|
|
|
// if this is true betreuer has zuordnung to the given $projektarbeit_id and conversely the $student_uid
|
|
// assigned to that project
|
|
if(hasData($res)) {
|
|
return true;
|
|
} else {
|
|
$berechtigt = $this->ProjektarbeitModel->hasBerechtigungForProjektarbeit($projektarbeit_id);
|
|
if($berechtigt) {
|
|
return true;
|
|
}
|
|
|
|
// otherwhise if there is no zuordnung via global admin or assistenz berechtigung,
|
|
// check if the given uid has permissions over the studiengang of the student
|
|
// via the abgabetool specific berechtigungen
|
|
// 'basis/abgabe_assistenz:rw' OR 'basis/abgabe_lektor:rw'
|
|
|
|
if ($this->permissionlib->isBerechtigt('basis/abgabe_assistenz', 'suid', $studiengang_kz)) {
|
|
return true;
|
|
}
|
|
|
|
if ($this->permissionlib->isBerechtigt('basis/abgabe_lektor', 'suid', $studiengang_kz)){
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private function getProjektarbeitIDForPaabgabeID($paabgabe_id) {
|
|
$this->load->model('education/Projektarbeit_model', 'ProjektarbeitModel');
|
|
|
|
$res = $this->ProjektarbeitModel->getProjektarbeitByPaabgabeID($paabgabe_id);
|
|
if(isError($res)) {
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4errorLoadingProjektarbeitForPaabgabeID'), 'general');
|
|
}
|
|
|
|
if(!hasData($res)) {
|
|
$this->terminateWithError($this->p->t('abgabetool', 'c4noAssignedProjektarbeitForPaabgabeID'), 'general');
|
|
}
|
|
$data = getData($res)[0];
|
|
return $data->projektarbeit_id;
|
|
}
|
|
|
|
private function checkZuordnungByPaabgabe($paabgabe_id, $betreuer_uid) {
|
|
$projektarbeit_id = $this->getProjektarbeitIDForPaabgabeID($paabgabe_id);
|
|
return $this->checkZuordnung($projektarbeit_id, $betreuer_uid);
|
|
}
|
|
|
|
// loads a projektarbeit table row by id and looks if a note has been set. A non null note field
|
|
// currently indicates that a projektarbeit has been finished and should not accept further crud manipulation
|
|
private function checkProjektarbeitForFinishedStatus($projektarbeit_id) {
|
|
$this->load->model('education/Projektarbeit_model', 'ProjektarbeitModel');
|
|
$res = $this->ProjektarbeitModel->load($projektarbeit_id);
|
|
|
|
if(isError($res) || !hasData($res)) {
|
|
$this->terminateWithError($this->p->t('abgabetool','c4projektarbeitNichtGefunden'), 'general');
|
|
}
|
|
|
|
$data = getData($res)[0];
|
|
if($data->note !== NULL) {
|
|
// hardcode this error msg cause phrasen arent reliable and people keep bugging why the cant edit old entries they definitely shouldnt update
|
|
$message = $this->p->t('abgabetool','c4fehlerAktualitaetProjektarbeitv2');
|
|
if(strpos($message, "<<") === 0) { // phrase could not be loaded
|
|
$this->terminateWithError('Die Projektarbeit wurde bereits benotet, Sie dürfen deshalb keine weiteren Termine anlegen oder bearbeiten.', 'general');
|
|
} else {
|
|
$this->terminateWithError($message);
|
|
}
|
|
}
|
|
}
|
|
|
|
} |