mirror of
https://github.com/FH-Complete/FHC-Core.git
synced 2026-06-01 20:29:29 +00:00
cgfhtw
2152 lines
67 KiB
PHP
2152 lines
67 KiB
PHP
<?php
|
|
|
|
/**
|
|
* FH-Complete
|
|
*
|
|
* @package FHC-Helper
|
|
* @author FHC-Team
|
|
* @copyright Copyright (c) 2023 fhcomplete.net
|
|
* @license GPLv3
|
|
*/
|
|
|
|
if (! defined('BASEPATH')) exit('No direct script access allowed');
|
|
|
|
use \DateTime as DateTime;
|
|
use \DOMDocument as DOMDocument;
|
|
use \XSLTProcessor as XSLTProcessor;
|
|
use \Studierendenantragstatus_model as Studierendenantragstatus_model;
|
|
use \stdClass as stdClass;
|
|
|
|
class AntragLib
|
|
{
|
|
|
|
/**
|
|
* Object initialization
|
|
*/
|
|
public function __construct()
|
|
{
|
|
$this->_ci =& get_instance();
|
|
|
|
// Configs
|
|
$this->_ci->load->config('studierendenantrag');
|
|
|
|
// Models
|
|
$this->_ci->load->model('education/Studierendenantrag_model', 'StudierendenantragModel');
|
|
$this->_ci->load->model('education/Studierendenantragstatus_model', 'StudierendenantragstatusModel');
|
|
$this->_ci->load->model('education/Studierendenantraglehrveranstaltung_model', 'StudierendenantraglehrveranstaltungModel');
|
|
$this->_ci->load->model('organisation/Studiengang_model', 'StudiengangModel');
|
|
$this->_ci->load->model('crm/Prestudent_model', 'PrestudentModel');
|
|
$this->_ci->load->model('crm/Prestudentstatus_model', 'PrestudentstatusModel');
|
|
$this->_ci->load->model('person/Person_model', 'PersonModel');
|
|
$this->_ci->load->model('education/Pruefung_model', 'PruefungModel');
|
|
|
|
// Helper
|
|
$this->_ci->load->helper('hlp_sancho_helper');
|
|
|
|
// Libraries
|
|
$this->_ci->load->library('PermissionLib');
|
|
$this->_ci->load->library('PrestudentLib');
|
|
}
|
|
|
|
/**
|
|
* @param integer $antrag_id
|
|
* @param string $insertvon
|
|
*
|
|
* @return stdClass
|
|
*/
|
|
public function cancelAntrag($antrag_id, $insertvon)
|
|
{
|
|
$result = $this->_ci->StudierendenantragstatusModel->insert([
|
|
'studierendenantrag_id' => $antrag_id,
|
|
'studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_CANCELLED,
|
|
'insertvon' => $insertvon
|
|
]);
|
|
|
|
// NOTE(chris): remove "preabbrecher" statusgrund and paused stati for sibling Anträge for Stgl-Abmeldungen if set
|
|
$res = $this->_ci->StudierendenantragModel->load($antrag_id);
|
|
if (hasData($res) && current(getData($res))->typ == Studierendenantrag_model::TYP_ABMELDUNG_STGL) {
|
|
$this->unpauseAntrag($antrag_id, Studierendenantragstatus_model::INSERTVON_ABMELDUNGSTGL);
|
|
|
|
$this->_ci->PrestudentstatusModel->addSelect('tbl_status_grund.statusgrund_kurzbz');
|
|
$res = $this->_ci->PrestudentstatusModel->getLastStatusWithStgEmail(current(getData($res))->prestudent_id, '', 'Student');
|
|
if (hasData($res) && current(getData($res))->statusgrund_kurzbz == 'preabbrecher') {
|
|
$prestudentstatus = current(getData($res));
|
|
$this->_ci->PrestudentstatusModel->update([
|
|
'prestudent_id' => $prestudentstatus->prestudent_id,
|
|
'status_kurzbz'=>$prestudentstatus->status_kurzbz,
|
|
'studiensemester_kurzbz'=>$prestudentstatus->studiensemester_kurzbz,
|
|
'ausbildungssemester'=>$prestudentstatus->ausbildungssemester
|
|
], [
|
|
'statusgrund_id' => null
|
|
]);
|
|
}
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* @param integer $antrag_id
|
|
* @param string $insertvon
|
|
*
|
|
* @return stdClass
|
|
*/
|
|
public function pauseAntrag($antrag_id, $insertvon)
|
|
{
|
|
switch ($insertvon) {
|
|
case Studierendenantragstatus_model::INSERTVON_ABMELDUNGSTGL:
|
|
$result = $this->_ci->StudierendenantragstatusModel->stopAntraegeForAbmeldungStgl($antrag_id);
|
|
break;
|
|
case Studierendenantragstatus_model::INSERTVON_DEREGISTERED:
|
|
$result = $this->_ci->StudierendenantragstatusModel->stopAntraegeForAbbruchBy($antrag_id);
|
|
break;
|
|
default:
|
|
$result = $this->_ci->StudierendenantragstatusModel->insert([
|
|
'studierendenantrag_id' => $antrag_id,
|
|
'studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_PAUSE,
|
|
'insertvon' => $insertvon
|
|
]);
|
|
break;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* @param integer $antrag_id
|
|
* @param string $insertvon
|
|
*
|
|
* @return stdClass
|
|
*/
|
|
public function unpauseAntrag($antrag_id, $insertvon)
|
|
{
|
|
if ($insertvon == Studierendenantragstatus_model::INSERTVON_DEREGISTERED)
|
|
return error($this->p->t('studierendenantrag', 'error_no_right'));
|
|
if ($insertvon == Studierendenantragstatus_model::INSERTVON_ABMELDUNGSTGL) {
|
|
return $this->_ci->StudierendenantragstatusModel->resumeAntraegeForAbmeldungStgl($antrag_id);
|
|
}
|
|
// NOTE(chris): get last status that is not pause
|
|
$this->_ci->StudierendenantragstatusModel->addOrder('insertamum');
|
|
$this->_ci->StudierendenantragstatusModel->addLimit(1);
|
|
$result = $this->_ci->StudierendenantragstatusModel->loadWhere([
|
|
'studierendenantrag_id' => $antrag_id,
|
|
'studierendenantrag_statustyp_kurzbz !=' => Studierendenantragstatus_model::STATUS_PAUSE
|
|
]);
|
|
if (isError($result))
|
|
return $result;
|
|
if (!hasData($result))
|
|
return error($this->_ci->p->t('studierendenantrag', 'error_no_antragstatus', ['id' => $antrag_id]));
|
|
$status = current(getData($result));
|
|
|
|
$result = $this->_ci->StudierendenantragstatusModel->insert([
|
|
'studierendenantrag_id' => $antrag_id,
|
|
'studierendenantrag_statustyp_kurzbz' => $status->studierendenantrag_statustyp_kurzbz,
|
|
'insertvon' => $insertvon
|
|
]);
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* NOTE(chris): permissions & verification must be handled outside
|
|
*
|
|
* @param integer $prestudent_id
|
|
* @param string $studiensemester_kurzbz
|
|
* @param string $insertvon
|
|
* @param string $grund
|
|
*
|
|
* @return stdClass
|
|
*/
|
|
public function createAbmeldung($prestudent_id, $studiensemester_kurzbz, $insertvon, $grund)
|
|
{
|
|
$result = $this->_ci->PrestudentModel->load($prestudent_id);
|
|
if (isError($result))
|
|
return $result;
|
|
if(!hasData($result))
|
|
return error($this->_ci->p->t('studierendenantrag', "error_no_prestudent", ['prestudent_id' => $prestudent_id]));
|
|
|
|
$prestudent = getData($result)[0];
|
|
if($prestudent->person_id == getAuthPersonId())
|
|
$typ = Studierendenantrag_model::TYP_ABMELDUNG;
|
|
else
|
|
$typ = Studierendenantrag_model::TYP_ABMELDUNG_STGL;
|
|
|
|
$result = $this->_ci->StudierendenantragModel->insert([
|
|
'prestudent_id' => $prestudent_id,
|
|
'studiensemester_kurzbz'=> $studiensemester_kurzbz,
|
|
'datum' => date('c'),
|
|
'typ' => $typ,
|
|
'insertvon' => $insertvon,
|
|
'grund' => $grund
|
|
]);
|
|
|
|
if (isError($result))
|
|
return $result;
|
|
|
|
$antrag_id = getData($result);
|
|
|
|
$result = $this->_ci->StudierendenantragstatusModel->insert([
|
|
'studierendenantrag_id' => $antrag_id,
|
|
'studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_CREATED,
|
|
'insertvon' => $insertvon
|
|
]);
|
|
|
|
if (isError($result))
|
|
return $result;
|
|
|
|
return success($antrag_id);
|
|
}
|
|
|
|
/**
|
|
* @param array $studierendenantrag_ids
|
|
* @param string $insertvon
|
|
*
|
|
* @return stdClass
|
|
*/
|
|
public function approveAbmeldung($studierendenantrag_ids, $insertvon)
|
|
{
|
|
$this->_ci->load->model('crm/Student_model', 'StudentModel');
|
|
|
|
$errors = [];
|
|
foreach ($studierendenantrag_ids as $studierendenantrag_id) {
|
|
$result = $this->_ci->StudierendenantragModel->load($studierendenantrag_id);
|
|
if (isError($result))
|
|
{
|
|
$errors[] = getError($result);
|
|
continue;
|
|
}
|
|
if(!hasData($result))
|
|
{
|
|
$errors[] = $this->_ci->p->t('studierendenantrag', 'error_no_antrag_found', ['id' => $studierendenantrag_id]);
|
|
continue;
|
|
}
|
|
$antrag = getData($result)[0];
|
|
|
|
$insertam = date('c');
|
|
|
|
$result = $this->_ci->StudierendenantragstatusModel->insert([
|
|
'studierendenantrag_id' => $studierendenantrag_id,
|
|
'studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_APPROVED,
|
|
'insertvon' => $insertvon,
|
|
'insertamum' => $insertam
|
|
]);
|
|
if (isError($result))
|
|
$errors[] = getError($result);
|
|
else {
|
|
$this->_ci->StudiengangModel->addJoin('public.tbl_prestudent ps', 'studiengang_kz');
|
|
$result = $this->_ci->StudiengangModel->loadWhere(['prestudent_id' => $antrag->prestudent_id]);
|
|
$stg = '';
|
|
$orgform = '';
|
|
if (hasData($result)) {
|
|
$studiengang = current(getData($result));
|
|
$stg = $studiengang->bezeichnung;
|
|
}
|
|
if ($antrag->typ == Studierendenantrag_model::TYP_ABMELDUNG)
|
|
{
|
|
$resultPrestudentStatus = $this->_ci->PrestudentstatusModel->getLastStatusWithStgEmail($antrag->prestudent_id);
|
|
if (isError($resultPrestudentStatus))
|
|
$errors[] = getError($resultPrestudentStatus);
|
|
|
|
else {
|
|
$prestudent_status = getData($resultPrestudentStatus)[0];
|
|
$orgform = $prestudent_status->orgform_kurzbz;
|
|
|
|
$vorlage ='Sancho_Mail_Antrag_A_Approve';
|
|
$subject = $this->_ci->p->t('studierendenantrag', 'mail_subject_A_Approve');
|
|
|
|
$result = $this->pauseAntrag($studierendenantrag_id, Studierendenantragstatus_model::INSERTVON_DEREGISTERED);
|
|
if (isError($result))
|
|
$errors[] = getError($result);
|
|
|
|
$result = $this->_ci->prestudentlib->setAbbrecher(
|
|
$antrag->prestudent_id,
|
|
$antrag->studiensemester_kurzbz,
|
|
$insertvon,
|
|
'abbrecherStud',
|
|
$antrag->datum,
|
|
$insertam
|
|
);
|
|
if (isError($result))
|
|
{
|
|
$errors[] = getError($result);
|
|
return $errors;
|
|
}
|
|
|
|
$result = $this->_ci->PersonModel->loadPrestudent($antrag->prestudent_id);
|
|
$data = [
|
|
'student' => $this->_ci->p->t('person', 'studentIn'),
|
|
'sem' => $antrag->studiensemester_kurzbz,
|
|
'linkPdf' => base_url('content/pdfExport.php?xml=Antrag' .
|
|
$antrag->typ .
|
|
'.xml.php&xsl=Antrag' .
|
|
$antrag->typ .
|
|
'&id=' .
|
|
$antrag->studierendenantrag_id .
|
|
'&output=pdf')
|
|
];
|
|
if (hasData($result)) {
|
|
$person = current(getData($result));
|
|
$data['student'] = trim($person->vorname . ' ' . $person->nachname);
|
|
$data['vorname'] = $person->vorname;
|
|
$data['nachname'] = $person->nachname;
|
|
}
|
|
$result = $this->_ci->StudentModel->loadWhere(['prestudent_id'=> $antrag->prestudent_id]);
|
|
if (hasData($result)) {
|
|
$student = current(getData($result));
|
|
$data['UID'] = $student->student_uid;
|
|
}
|
|
|
|
$data['Orgform'] = $prestudent_status->orgform;
|
|
$data['stg'] = $stg;
|
|
|
|
// NOTE(chris): Sancho mail
|
|
sendSanchoMail($vorlage, $data, $prestudent_status->email, $subject);
|
|
}
|
|
} else { // ($antrag->typ == Studierendenantrag_model::TYP_ABMELDUNG_STGL)
|
|
$result = $this->pauseAntrag($studierendenantrag_id, Studierendenantragstatus_model::INSERTVON_ABMELDUNGSTGL);
|
|
if (isError($result))
|
|
$errors[] = getError($result);
|
|
|
|
$result = $this->_ci->PrestudentstatusModel->getLastStatusWithStgEmail($antrag->prestudent_id, '', 'Student');
|
|
if (isError($result))
|
|
{
|
|
$errors[] = getError($result);
|
|
continue;
|
|
}
|
|
if(!hasData($result))
|
|
{
|
|
$errors[] = $this->_ci->p->t('studierendenantrag', 'error_no_prestudentstatus', ['prestudent_id' => $antrag->prestudent_id]);
|
|
continue;
|
|
}
|
|
$prestudentstatus = getData($result)[0];
|
|
$orgform = $prestudentstatus->orgform_kurzbz;
|
|
|
|
$result = $this->_ci->PrestudentstatusModel->withGrund('preabbrecher')->update([
|
|
'prestudent_id' => $prestudentstatus->prestudent_id,
|
|
'status_kurzbz'=>$prestudentstatus->status_kurzbz,
|
|
'studiensemester_kurzbz'=>$prestudentstatus->studiensemester_kurzbz,
|
|
'ausbildungssemester'=>$prestudentstatus->ausbildungssemester
|
|
], []);
|
|
if (isError($result))
|
|
{
|
|
$errors[] = getError($result);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
$res = $this->_ci->PrestudentModel->load($antrag->prestudent_id);
|
|
|
|
if (hasData($res)) {
|
|
$prestudent = current(getData($res));
|
|
$res = $this->_ci->PersonModel->load($prestudent->person_id);
|
|
if (hasData($res)) {
|
|
$person = current(getData($res));
|
|
$name = trim($person->vorname . ' ' . $person->nachname);
|
|
$vorname = $person->vorname;
|
|
$nachname = $person->nachname;
|
|
} else {
|
|
$name = $this->_ci->p->t('person', 'studentIn');
|
|
$vorname = '';
|
|
$nachname = $name;
|
|
}
|
|
$res = $this->_ci->StudentModel->loadWhere(['prestudent_id' => $antrag->prestudent_id]);
|
|
if (hasData($res)) {
|
|
$email = $this->_ci->StudentModel->getEmailFH(current(getData($res))->student_uid);
|
|
$vorlage = $antrag->typ == Studierendenantrag_model::TYP_ABMELDUNG ? 'Student' : 'Stgl';
|
|
|
|
// NOTE(chris): Sancho mail
|
|
sendSanchoMail(
|
|
'Sancho_Mail_Antrag_A_' . $vorlage,
|
|
[
|
|
'name' => $name,
|
|
'grund' => $antrag->grund,
|
|
'vorname' => $vorname,
|
|
'nachname' => $nachname,
|
|
'Orgform' => $orgform,
|
|
'stg' => $stg
|
|
],
|
|
$email,
|
|
$this->_ci->p->t('studierendenantrag', 'mail_subject_A_' . $vorlage)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (count($errors))
|
|
return error(implode(',', $errors));
|
|
|
|
return success();
|
|
}
|
|
|
|
/**
|
|
* @param integer $studierendenantrag_id
|
|
* @param string $insertvon
|
|
*
|
|
* @return stdClass
|
|
*/
|
|
public function denyObjectionAbmeldung($studierendenantrag_id, $insertvon, $grund = null)
|
|
{
|
|
$result = $this->_ci->StudierendenantragModel->load($studierendenantrag_id);
|
|
if (isError($result))
|
|
{
|
|
return $result;
|
|
}
|
|
if(!hasData($result))
|
|
{
|
|
return error($this->_ci->p->t('studierendenantrag', 'error_no_antrag_found', ['id' => $studierendenantrag_id]));
|
|
}
|
|
$antrag = getData($result)[0];
|
|
|
|
$result = $this->_ci->StudierendenantragstatusModel->loadWhere([
|
|
'studierendenantrag_id' => $studierendenantrag_id,
|
|
'studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_APPROVED
|
|
]);
|
|
if (isError($result))
|
|
return $result;
|
|
if (!hasData($result))
|
|
return error($this->_ci->p->t('studierendenantrag', 'error_not_approved'));
|
|
|
|
$status = current(getData($result));
|
|
|
|
$result = $this->_ci->StudierendenantragstatusModel->insert([
|
|
'studierendenantrag_id' => $studierendenantrag_id,
|
|
'studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_OBJECTION_DENIED,
|
|
'grund' => $grund,
|
|
'insertvon' => $insertvon
|
|
]);
|
|
if (isError($result))
|
|
return $result;
|
|
else {
|
|
$result = $this->pauseAntrag($studierendenantrag_id, Studierendenantragstatus_model::INSERTVON_DEREGISTERED);
|
|
// NOTE(chris): here we should have error handling but at the
|
|
// moment there is no way to notify the user for "soft" errors
|
|
|
|
$result = $this->_ci->prestudentlib->setAbbrecher(
|
|
$antrag->prestudent_id,
|
|
$antrag->studiensemester_kurzbz,
|
|
$insertvon,
|
|
'abbrecherStgl',
|
|
$status->insertamum
|
|
);
|
|
|
|
if (isError($result))
|
|
return $result;
|
|
|
|
$res = $this->_ci->PrestudentModel->load($antrag->prestudent_id);
|
|
|
|
if (hasData($res)) {
|
|
$this->_ci->load->model('crm/Student_model', 'StudentModel');
|
|
|
|
$prestudent = current(getData($res));
|
|
$res = $this->_ci->PersonModel->load($prestudent->person_id);
|
|
if (hasData($res)) {
|
|
$person = current(getData($res));
|
|
$name = trim($person->vorname . ' ' . $person->nachname);
|
|
$vorname = $person->vorname;
|
|
$nachname = $person->nachname;
|
|
} else {
|
|
$name = $this->_ci->p->t('person', 'studentIn');
|
|
}
|
|
|
|
$res = $this->_ci->StudentModel->loadWhere(['prestudent_id' => $antrag->prestudent_id]);
|
|
if (hasData($res)) {
|
|
$email = $this->_ci->StudentModel->getEmailFH(current(getData($res))->student_uid);
|
|
|
|
$res = $this->_ci->StudierendenantragModel->getStgAndSem($antrag->studierendenantrag_id);
|
|
$stg = '';
|
|
$orgform = '';
|
|
if (hasData($res)) {
|
|
$studiengang = current(getData($res));
|
|
$stg = $studiengang->bezeichnung;
|
|
$orgform = $studiengang->orgform_kurzbz;
|
|
}
|
|
|
|
sendSanchoMail(
|
|
'Sancho_Mail_Antrag_A_ObjDenied',
|
|
[
|
|
'name' => $name,
|
|
'vorname' => $vorname,
|
|
'nachname' => $nachname,
|
|
'grund' => $grund,
|
|
'Orgform' => $orgform,
|
|
'stg' => $stg
|
|
],
|
|
$email,
|
|
$this->_ci->p->t('studierendenantrag', 'mail_subject_A_ObjectionDenied')
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
return success();
|
|
}
|
|
|
|
/**
|
|
* NOTE(chris): permissions & verification must be handled outside
|
|
*
|
|
* @param integer $prestudent_id
|
|
* @param string $studiensemester_kurzbz
|
|
* @param string $insertvon
|
|
* @param string $grund
|
|
* @param string $datum_wiedereinstieg
|
|
*
|
|
* @return stdClass
|
|
*/
|
|
public function createUnterbrechung($prestudent_id, $studiensemester_kurzbz, $insertvon, $grund, $datum_wiedereinstieg, $dms_id)
|
|
{
|
|
$datum_wiedereinstieg = new DateTime($datum_wiedereinstieg);
|
|
$datum_wiedereinstieg = $datum_wiedereinstieg->format("Y-m-d");
|
|
$result = $this->_ci->StudierendenantragModel->insert([
|
|
'prestudent_id' => $prestudent_id,
|
|
'studiensemester_kurzbz'=> $studiensemester_kurzbz,
|
|
'datum' => date('c'),
|
|
'typ' => Studierendenantrag_model::TYP_UNTERBRECHUNG,
|
|
'insertvon' => $insertvon,
|
|
'grund' => $grund,
|
|
'datum_wiedereinstieg' => $datum_wiedereinstieg,
|
|
'dms_id' => $dms_id
|
|
]);
|
|
|
|
if (isError($result))
|
|
return $result;
|
|
|
|
$antrag_id = getData($result);
|
|
|
|
$result = $this->_ci->StudierendenantragstatusModel->insert([
|
|
'studierendenantrag_id' => $antrag_id,
|
|
'studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_CREATED,
|
|
'insertvon' => $insertvon
|
|
]);
|
|
|
|
if (isError($result))
|
|
return $result;
|
|
|
|
return success($antrag_id);
|
|
}
|
|
|
|
|
|
/**
|
|
* @param array $studierendenantrag_ids
|
|
* @param string $insertvon
|
|
*
|
|
* @return stdClass
|
|
*/
|
|
public function approveUnterbrechung($studierendenantrag_ids, $insertvon)
|
|
{
|
|
$this->_ci->load->model('person/Kontakt_model', 'KontaktModel');
|
|
$this->_ci->load->model('crm/Student_model', 'StudentModel');
|
|
|
|
$errors = [];
|
|
|
|
foreach ($studierendenantrag_ids as $studierendenantrag_id)
|
|
{
|
|
$data = $this->getDataForUnterbrechung($studierendenantrag_id);
|
|
|
|
if (isError($data)) {
|
|
$error_msg = getError($data);
|
|
if (is_array($error_msg) && isset($error_msg['message']))
|
|
$error_msg = $error_msg['message'];
|
|
|
|
$errors['failed_' . $studierendenantrag_id] = 'Could not approve Unterbrechung for studierendenantrag_id: ' .
|
|
$studierendenantrag_id .
|
|
'<br>Details:<br>' .
|
|
$error_msg;
|
|
} else {
|
|
$data = getData($data);
|
|
|
|
$result = $this->_ci->StudierendenantragstatusModel->insert([
|
|
'studierendenantrag_id' => $studierendenantrag_id,
|
|
'studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_APPROVED,
|
|
'insertvon' => $insertvon
|
|
]);
|
|
if (isError($result))
|
|
{
|
|
$errors['failed_' . $studierendenantrag_id] = $this->_ci->p->t('studierendenantrag', 'error_U_Approve', [
|
|
'studierendenantrag_id' => $studierendenantrag_id,
|
|
'message' => getError($result)['message']
|
|
]);
|
|
}
|
|
else
|
|
{
|
|
$studierendenantrag_status_id = getData($result);
|
|
$resultAntrag = $this->_ci->StudierendenantragModel->load($studierendenantrag_id);
|
|
if (isError($resultAntrag))
|
|
return $resultAntrag;
|
|
$resultAntrag = getData($resultAntrag);
|
|
if (!$resultAntrag)
|
|
return error($this->_ci->p->t('studierendenantrag', 'error_no_antrag_found', ['id' => $studierendenantrag_id]));
|
|
$resultAntrag = current($resultAntrag);
|
|
|
|
// Prestudentstatus und Unterbrechungsfolgeaktionen setzen
|
|
$result = $this->_ci->prestudentlib->setUnterbrecher(
|
|
$resultAntrag->prestudent_id,
|
|
$resultAntrag->studiensemester_kurzbz,
|
|
$studierendenantrag_id
|
|
);
|
|
|
|
if (isError($result)) {
|
|
$this->_ci->StudierendenantragstatusModel->delete($studierendenantrag_status_id);
|
|
return $result;
|
|
}
|
|
|
|
|
|
//Mail
|
|
$subject = $this->_ci->p->t('studierendenantrag', 'mail_subject_U_Approve');
|
|
$mail = [];
|
|
|
|
if (isset($data['errors']['person_id']))
|
|
{
|
|
//send assistenz mit id
|
|
$errors[] = $this->_ci->p->t('studierendenantrag', 'error_mail_and_name', ['message' => $data['errors']['person_id']]);
|
|
$mail['ass'] = $this->_ci->p->t('studierendenantrag', 'StudentIn', ['prestudent_id' => $data['antrag']->prestudent_id]);
|
|
}
|
|
elseif (isset($data['errors']['email']))
|
|
{
|
|
if (isset($data['errors']['person']))
|
|
{
|
|
//send assistenz mit id
|
|
$errors[] = $this->_ci->p->t('studierendenantrag', 'error_mail_and_name', [
|
|
'message' => $data['errors']['email'] . '<br>' . $data['errors']['person']
|
|
]);
|
|
$mail['ass'] = $this->_ci->p->t('studierendenantrag', 'StudentIn', ['prestudent_id' => $data['antrag']->prestudent_id]);
|
|
}
|
|
else
|
|
{
|
|
//send assistenz mit name
|
|
$errors[] = $this->_ci->p->t('studierendenantrag', 'error_mail', ['message' => $data['errors']['email']]);
|
|
$mail['ass'] = trim($data['person']->vorname . ' ' . $data['person']->nachname);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (isset($data['errors']['person']))
|
|
{
|
|
//send assistenz mit id & student mit "Student/in"
|
|
$errors[] = $this->_ci->p->t('studierendenantrag', 'error_name', ['message' => $data['errors']['person']]);
|
|
$mail['ass'] = $this->_ci->p->t('studierendenantrag', 'StudentIn', ['prestudent_id' => $data['antrag']->prestudent_id]);
|
|
$mail['stu'] = $this->_ci->p->t('person', 'StudentIn');
|
|
}
|
|
else
|
|
{
|
|
//send normal
|
|
$mail['ass'] = $mail['stu'] = trim($data['person']->vorname . ' ' . $data['person']->nachname);
|
|
}
|
|
}
|
|
|
|
if (isset($mail['ass'])) {
|
|
// NOTE(chris): Sancho mail
|
|
$mailVorlage = 'Sancho_Mail_Antrag_U_Approve';
|
|
|
|
$result = $this->_ci->StudentModel->loadWhere(['prestudent_id'=> $data['antrag']->prestudent_id]);
|
|
if (hasData($result)) {
|
|
$student = current(getData($result));
|
|
$data['UID'] = $student->student_uid;
|
|
}
|
|
|
|
$result = $this->_ci->PersonModel->getFullName($insertvon);
|
|
if (isError($result))
|
|
return $result;
|
|
$approvedBy = $insertvon;
|
|
if (hasData($result))
|
|
{
|
|
$approvedBy = getData($result);
|
|
}
|
|
|
|
if (!sendSanchoMail(
|
|
$mailVorlage,
|
|
[
|
|
'name' => $mail['ass'],
|
|
'stg' => $data['studiengang']->bezeichnung,
|
|
'Orgform' => $data['prestudent_status']->orgform_kurzbz,
|
|
'vorname' => $data['person']->vorname,
|
|
'nachname' => $data['person']->nachname,
|
|
'UID' => $data['UID'],
|
|
'sem' => $resultAntrag->studiensemester_kurzbz,
|
|
'linkPdf' => base_url(
|
|
'content/pdfExport.php?xml=AntragUnterbrechung.xml.php&xsl=AntragUnterbrechung&id=' .
|
|
$studierendenantrag_id .
|
|
'&output=pdf'
|
|
),
|
|
'insertvon' => $approvedBy
|
|
],
|
|
$data['prestudent_status']->email,
|
|
$subject
|
|
)) {
|
|
$errors[] = $this->_ci->p->t('studierendenantrag', 'error_mail_to', $data['prestudent_status']);
|
|
}
|
|
}
|
|
if (isset($mail['stu'])) {
|
|
// NOTE(chris): Sancho mail
|
|
$mailVorlage = 'Sancho_Mail_Antrag_U_Student';
|
|
if ($data['studienbeitrag'])
|
|
$mailVorlage .= '_SB';
|
|
if (!sendSanchoMail(
|
|
$mailVorlage,
|
|
[
|
|
'name' => $mail['stu'],
|
|
'stg' => $data['studiengang']->bezeichnung,
|
|
'Orgform' => $data['prestudent_status']->orgform_kurzbz,
|
|
'vorname' => $data['person']->vorname,
|
|
'nachname' => $data['person']->nachname
|
|
],
|
|
$data['email'],
|
|
$subject
|
|
)) {
|
|
$errors[] = $this->_ci->p->t('studierendenantrag', 'error_mail_to', $data);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (count($errors))
|
|
return error($errors);
|
|
|
|
return success();
|
|
}
|
|
|
|
/**
|
|
* @param array $studierendenantrag_ids
|
|
* @param string $insertvon
|
|
* @param string $grund
|
|
*
|
|
* @return stdClass
|
|
*/
|
|
public function rejectUnterbrechung($studierendenantrag_ids, $insertvon, $grund)
|
|
{
|
|
$this->_ci->load->model('person/Kontakt_model', 'KontaktModel');
|
|
$this->_ci->load->model('crm/Student_model', 'StudentModel');
|
|
|
|
$errors = [];
|
|
|
|
foreach ($studierendenantrag_ids as $studierendenantrag_id) {
|
|
$data = $this->getDataForUnterbrechung($studierendenantrag_id);
|
|
|
|
if (isError($data)) {
|
|
$error_msg = getError($data);
|
|
if (is_array($error_msg) && isset($error_msg['message']))
|
|
$error_msg = $error_msg['message'];
|
|
|
|
$errors['failed_' . $studierendenantrag_id] = $this->_ci->p->t('studierendenantrag', 'error_U_Reject', [
|
|
'studierendenantrag_id' => $studierendenantrag_id,
|
|
'message' => $error_msg
|
|
]);
|
|
} else {
|
|
$data = getData($data);
|
|
|
|
$result = $this->_ci->StudierendenantragstatusModel->insert([
|
|
'studierendenantrag_id' => $studierendenantrag_id,
|
|
'studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_REJECTED,
|
|
'insertvon' => $insertvon,
|
|
'grund' => $grund
|
|
]);
|
|
if (isError($result)) {
|
|
$errors['failed_' . $studierendenantrag_id] = $this->_ci->p->t('studierendenantrag', 'error_U_Reject', [
|
|
'studierendenantrag_id' => $studierendenantrag_id,
|
|
'message' => getError($result)['message']
|
|
]);
|
|
} else {
|
|
$name = '';
|
|
|
|
if (isset($data['errors']['person_id']) || isset($data['errors']['email'])) {
|
|
$error_msg = [];
|
|
if (isset($data['errors']['person_id']))
|
|
$error_msg[] = $data['errors']['person_id'];
|
|
if (isset($data['errors']['email']))
|
|
$error_msg[] = $data['errors']['email'];
|
|
$error_msg = $this->_ci->p->t('studierendenantrag', 'error_mail', ['message' => implode('<br>', $error_msg)]);
|
|
$errors[] = $error_msg;
|
|
} else {
|
|
if (isset($data['errors']['person'])) {
|
|
//send student mit "Student/in"
|
|
$errors[] = $this->_ci->p->t('studierendenantrag', 'error_name', ['message' => $data['errors']['person']]);
|
|
$name = $this->_ci->p->t('person', 'studentIn');
|
|
$vorname = "";
|
|
$nachname = $name;
|
|
} else {
|
|
//send normal
|
|
$name = trim($data['person']->vorname . ' ' . $data['person']->nachname);
|
|
$vorname = $data['person']->vorname;
|
|
$nachname = $data['person']->nachname;
|
|
}
|
|
}
|
|
if ($name)
|
|
// NOTE(chris): Sancho mail
|
|
if (!sendSanchoMail(
|
|
'Sancho_Mail_Antrag_U_Reject',
|
|
[
|
|
'name' => $name,
|
|
'vorname' => $vorname,
|
|
'nachname' => $nachname,
|
|
'grund' => $grund,
|
|
'stg' => $data['studiengang']->bezeichnung,
|
|
'Orgform' => $data['prestudent_status']->orgform_kurzbz,
|
|
'prestudent_id' => $data['prestudent_status']->prestudent_id,
|
|
'abmeldungLink' => site_url('lehre/Studierendenantrag/abmeldung/' . $data['prestudent_status']->prestudent_id),
|
|
'abmeldungLinkCIS' => CIS_ROOT .
|
|
'index.ci.php/lehre/Studierendenantrag/abmeldung/' .
|
|
$data['prestudent_status']->prestudent_id
|
|
],
|
|
$data['email'],
|
|
$this->_ci->p->t('studierendenantrag', 'mail_subject_U_Reject')
|
|
))
|
|
$errors[] = $this->_ci->p->t('studierendenantrag', 'error_mail_to', $data);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (count($errors))
|
|
return error($errors);
|
|
|
|
return success();
|
|
}
|
|
|
|
/**
|
|
* @param integer $studierendenantrag_id
|
|
*
|
|
* @return array
|
|
*/
|
|
private function getDataForUnterbrechung($studierendenantrag_id)
|
|
{
|
|
$result = [];
|
|
$errors = [];
|
|
|
|
$res = $this->_ci->StudierendenantragModel->load($studierendenantrag_id);
|
|
if (isError($res))
|
|
return $res;
|
|
|
|
$res = getData($res);
|
|
if (!$res)
|
|
return error($this->_ci->p->t('studierendenantrag', 'error_no_antrag_found', ['id' => $studierendenantrag_id]));
|
|
|
|
$result['antrag'] = $antrag = current($res);
|
|
$this->_ci->StudiengangModel->addJoin('public.tbl_prestudent ps', 'studiengang_kz');
|
|
$res = $this->_ci->StudiengangModel->loadWhere(['prestudent_id' => $antrag->prestudent_id]);
|
|
if (hasData($res)) {
|
|
$result['studiengang'] = current(getData($res));
|
|
}
|
|
else{
|
|
$result['studiengang'] = new stdClass();
|
|
$result['studiengang']->bezeichnung = "";
|
|
}
|
|
|
|
$res = $this->_ci->PrestudentstatusModel->getLastStatusWithStgEmail($antrag->prestudent_id);
|
|
if (isError($res))
|
|
return $res;
|
|
|
|
$res = getData($res);
|
|
if (!$res)
|
|
return error($this->_ci->p->t('studierendenantrag', 'error_no_prestudentstatus', $antrag));
|
|
|
|
$result['prestudent_status'] = current($res);
|
|
|
|
|
|
$res = $this->_ci->PrestudentModel->load($antrag->prestudent_id);
|
|
|
|
if (isError($res)) {
|
|
$errors['person_id'] = getError($res);
|
|
} else {
|
|
$res = getData($res);
|
|
if (!$res) {
|
|
$errors['person_id'] = $this->_ci->p->t('studierendenantrag', 'error_no_prestudent', $antrag);
|
|
} else {
|
|
$person_id = current($res)->person_id;
|
|
|
|
$res = $this->_ci->PersonModel->load($person_id);
|
|
if (isError($res)) {
|
|
$errors['person'] = getError($res);
|
|
} else {
|
|
$res = getData($res);
|
|
if (!$res) {
|
|
$errors['person'] = $this->_ci->p->t('studierendenantrag', 'error_no_person', ['person_id' => $person_id]);
|
|
} else {
|
|
$result['person'] = current($res);
|
|
}
|
|
}
|
|
|
|
$res = $this->_ci->StudentModel->loadWhere(['prestudent_id' => $antrag->prestudent_id]);
|
|
if (isError($res)) {
|
|
$errors['email'] = getError($res);
|
|
} else {
|
|
$res = getData($res);
|
|
|
|
if (!$res) {
|
|
$errors['email'] = $this->_ci->p->t('studierendenantrag', 'error_no_email', ['person_id' => $person_id]);
|
|
} else {
|
|
$result['email'] = $this->_ci->StudentModel->getEmailFH(current($res)->student_uid);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
$result['studienbeitrag'] = false;
|
|
if (!isset($errors['person_id'])) {
|
|
$date_target = new DateTime(
|
|
$this->_ci->config->item('frist_rueckzahlung_studiengebuer_' . substr($result['antrag']->studiensemester_kurzbz, 0, 2)) .
|
|
substr($result['antrag']->studiensemester_kurzbz, 2)
|
|
);
|
|
$date_created = new DateTime($result['antrag']->datum);
|
|
if ($date_created < $date_target) {
|
|
$this->_ci->load->model('crm/Konto_model', 'KontoModel');
|
|
$result['studienbeitrag'] = $this->_ci->KontoModel->checkStudienbeitragFromPerson(
|
|
$person_id,
|
|
$result['antrag']->studiensemester_kurzbz
|
|
);
|
|
}
|
|
}
|
|
|
|
$result['errors'] = $errors;
|
|
|
|
return success($result);
|
|
}
|
|
|
|
/**
|
|
* @param integer $prestudent_id
|
|
* @param string $studiensemester_kurzbz
|
|
* @param string $insertvon
|
|
* @param boolean $repeat
|
|
*
|
|
* @return stdClass
|
|
*/
|
|
public function createWiederholung($prestudent_id, $studiensemester_kurzbz, $insertvon, $repeat)
|
|
{
|
|
$result = $this->_ci->StudierendenantragModel->loadIdAndStatusWhere([
|
|
'prestudent_id' => $prestudent_id,
|
|
'studiensemester_kurzbz'=> $studiensemester_kurzbz,
|
|
'typ' => Studierendenantrag_model::TYP_WIEDERHOLUNG
|
|
]);
|
|
|
|
$antrag_id = null;
|
|
if (hasData($result)) {
|
|
$antrag = current(getData($result));
|
|
if ($antrag->status == Studierendenantragstatus_model::STATUS_REOPENED ||
|
|
$antrag->status == Studierendenantragstatus_model::STATUS_REQUESTSENT_1 ||
|
|
$antrag->status == Studierendenantragstatus_model::STATUS_REQUESTSENT_2)
|
|
{
|
|
$antrag_id = $antrag->studierendenantrag_id;
|
|
}
|
|
else
|
|
{
|
|
return error($this->_ci->p->t('global', 'antragBereitsGestellt'));
|
|
}
|
|
}
|
|
|
|
if ($antrag_id === null) {
|
|
$result = $this->_ci->StudierendenantragModel->insert([
|
|
'prestudent_id' => $prestudent_id,
|
|
'studiensemester_kurzbz'=> $studiensemester_kurzbz,
|
|
'datum' => date('c'),
|
|
'typ' => Studierendenantrag_model::TYP_WIEDERHOLUNG,
|
|
'insertvon' => $insertvon
|
|
]);
|
|
|
|
if (isError($result))
|
|
return $result;
|
|
|
|
$antrag_id = getData($result);
|
|
}
|
|
|
|
$result = $this->_ci->StudierendenantragstatusModel->insert([
|
|
'studierendenantrag_id' => $antrag_id,
|
|
'studierendenantrag_statustyp_kurzbz' => $repeat
|
|
? Studierendenantragstatus_model::STATUS_CREATED
|
|
: Studierendenantragstatus_model::STATUS_PASS,
|
|
'insertvon' => $insertvon
|
|
]);
|
|
|
|
if ($repeat) {
|
|
$res = $this->_ci->PrestudentstatusModel->getLastStatusWithStgEmail($prestudent_id);
|
|
if (isError($res))
|
|
return $res;
|
|
$res = getData($res);
|
|
if (!$res)
|
|
return error($this->_ci->p->t('studierendenantrag', 'error_no_prestudentstatus', ['prestudent_id' => $prestudent_id]));
|
|
|
|
$prestudent_status = current($res);
|
|
$email = $prestudent_status->email;
|
|
// NOTE(chris): Sancho mail
|
|
$lvzuweisungLink = site_url('lehre/Antrag/Wiederholung/assistenz/' . $antrag_id);
|
|
if (defined('VILESCI_ROOT')) {
|
|
$lvzuweisungLink = VILESCI_ROOT . 'index.ci.php/lehre/Antrag/Wiederholung/assistenz/' . $antrag_id;
|
|
}
|
|
sendSanchoMail(
|
|
'Sancho_Mail_Antrag_W_New',
|
|
[
|
|
'antrag_id' => $antrag_id,
|
|
'stg' => $prestudent_status->stg_bezeichnung,
|
|
'Orgform' => $prestudent_status->orgform,
|
|
'lvzuweisungLink' => $lvzuweisungLink
|
|
],
|
|
$email,
|
|
$this->_ci->p->t('studierendenantrag', 'mail_subject_W_New')
|
|
);
|
|
}
|
|
|
|
if (isError($result))
|
|
return $result;
|
|
|
|
return success($antrag_id);
|
|
}
|
|
|
|
/**
|
|
* @param integer $studierendenantrag_id
|
|
* @param string $insertvon
|
|
*
|
|
* @return stdClass
|
|
*/
|
|
public function reopenWiederholung($studierendenantrag_id, $insertvon)
|
|
{
|
|
$result = $this->_ci->StudierendenantragstatusModel->insert([
|
|
'studierendenantrag_id' => $studierendenantrag_id,
|
|
'studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_REOPENED,
|
|
'insertvon' => $insertvon
|
|
]);
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* @param integer $studierendenantrag_id
|
|
* @param string $objectedvon
|
|
*
|
|
* @return stdClass
|
|
*/
|
|
public function objectAbmeldung($studierendenantrag_id, $objectedvon)
|
|
{
|
|
$result = $this->_ci->StudierendenantragstatusModel->insert([
|
|
'studierendenantrag_id' => $studierendenantrag_id,
|
|
'studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_OBJECTED,
|
|
'insertvon' => $objectedvon
|
|
]);
|
|
return $result;
|
|
}
|
|
|
|
public function getWiederholungsAntraege($status)
|
|
{
|
|
$studiengaenge = $this->_ci->permissionlib->getSTG_isEntitledFor('student/studierendenantrag');
|
|
$result = $this->_ci->StudierendenantragModel->loadForStudiengaenge(
|
|
$studiengaenge,
|
|
Studierendenantrag_model::TYP_WIEDERHOLUNG,
|
|
$status
|
|
);
|
|
if (!getData($result))
|
|
return $result;
|
|
$result = getData($result);
|
|
$grouped = [];
|
|
|
|
foreach ($result as $item) {
|
|
if (!isset($grouped[$item->studiengang_kz])) {
|
|
$grouped[$item->studiengang_kz] = [
|
|
'bezeichnung' => $item->bezeichnung,
|
|
'bezeichnung_mehrsprachig' => $item->bezeichnung_mehrsprachig,
|
|
'antraege' => []
|
|
];
|
|
}
|
|
$grouped[$item->studiengang_kz]['antraege'][] = $item;
|
|
}
|
|
|
|
return success($grouped);
|
|
}
|
|
|
|
public function getLvsForAntrag($antrag_id)
|
|
{
|
|
$this->_ci->load->model('education/Lehrveranstaltung_model', 'LehrveranstaltungModel');
|
|
$this->_ci->load->model('organisation/Studiensemester_model', 'StudiensemesterModel');
|
|
$this->_ci->load->model('organisation/Studienplan_model', 'StudienplanModel');
|
|
|
|
$result = $this->_ci->StudierendenantragModel->load($antrag_id);
|
|
if (isError($result))
|
|
return $result;
|
|
$result = getData($result);
|
|
if (!$result)
|
|
return error($this->_ci->p->t('studierendenantrag', 'error_no_antrag_found', ['id' => $antrag_id]));
|
|
$antrag = current($result);
|
|
|
|
|
|
$result = $this->_ci->StudierendenantragModel->getStgAndSem($antrag_id);
|
|
if (isError($result))
|
|
return $result;
|
|
$result = getData($result);
|
|
if (!$result)
|
|
return error($this->_ci->p->t('studierendenantrag', 'error_no_stg_and_sem', ['id' => $antrag_id]));
|
|
$result = current($result);
|
|
$studiengang_kz = $result->studiengang_kz;
|
|
$orgform_kurzbz = $result->orgform_kurzbz;
|
|
$ausbildungssemester = $result->ausbildungssemester;
|
|
$sprache = $result->sprache;
|
|
|
|
// NOTE(chris): check permission
|
|
$allowedStgs = $this->_ci->permissionlib->getSTG_isEntitledFor('student/studierendenantrag') ?: [];
|
|
if (!in_array($studiengang_kz, $allowedStgs)) {
|
|
$allowedStgs = $this->_ci->permissionlib->getSTG_isEntitledFor('student/antragfreigabe') ?: [];
|
|
if (!in_array($studiengang_kz, $allowedStgs)) {
|
|
if(!$this->isOwnAntrag($antrag_id))
|
|
return error('Forbidden');
|
|
}
|
|
}
|
|
|
|
|
|
$result = $this->_ci->StudiensemesterModel->getNextFrom($antrag->studiensemester_kurzbz);
|
|
if (isError($result))
|
|
return $result;
|
|
$result = getData($result);
|
|
if (!$result)
|
|
return error($this->_ci->p->t('studierendenantrag', 'error_no_sem_after', ['semester' => $antrag->studiensemester_kurzbz]));
|
|
$semA = current($result)->studiensemester_kurzbz;
|
|
|
|
$result = $this->_ci->StudiensemesterModel->getNextFrom($semA);
|
|
if (isError($result))
|
|
return $result;
|
|
$result = getData($result);
|
|
if (!$result)
|
|
return error($this->_ci->p->t('studierendenantrag', 'error_no_sem_after', ['semester' => $semA]));
|
|
$semB = current($result)->studiensemester_kurzbz;
|
|
|
|
$result = $this->_ci->StudierendenantraglehrveranstaltungModel->loadWhere(['studierendenantrag_id' => $antrag_id]);
|
|
if (isError($result))
|
|
return $result;
|
|
$result = getData($result) ?: [];
|
|
|
|
$lvszugewiesen = array();
|
|
foreach ($result as $lv)
|
|
{
|
|
$lvszugewiesen[$lv->lehrveranstaltung_id] = $lv;
|
|
}
|
|
|
|
$result = $this->getLvsByStgStsemAndSem(
|
|
$studiengang_kz,
|
|
$orgform_kurzbz,
|
|
$semA,
|
|
$ausbildungssemester + 1,
|
|
$antrag->prestudent_id,
|
|
$sprache
|
|
);
|
|
if (isError($result))
|
|
return $result;
|
|
$lvsA = $result->retval; // NOTE(chris): don't use getData() because we want to differenciate [] and null
|
|
$repeat_last = false;
|
|
if ($lvsA) {
|
|
foreach($lvsA as $lv)
|
|
{
|
|
if (isset($lvszugewiesen[$lv->lehrveranstaltung_id]) &&
|
|
($lvszugewiesen[$lv->lehrveranstaltung_id]->note == $this->_ci->config->item('wiederholung_note_nicht_zugelassen')))
|
|
{
|
|
$lv->antrag_zugelassen = true;
|
|
$lv->antrag_anmerkung = $lvszugewiesen[$lv->lehrveranstaltung_id]->anmerkung;
|
|
}
|
|
}
|
|
} elseif ($lvsA === null) {
|
|
// NOTE(chris): We are repeating the last semester
|
|
$repeat_last = true;
|
|
|
|
$result = $this->_ci->PrestudentstatusModel->getStatusByFilter($antrag->prestudent_id, 'Student', $ausbildungssemester - 1);
|
|
if (isError($result))
|
|
return $result;
|
|
|
|
$stdsems = getData($result) ?: [];
|
|
$stdsem = null;
|
|
|
|
$result = $this->_ci->StudiensemesterModel->load($antrag->studiensemester_kurzbz);
|
|
if (isError($result))
|
|
return $result;
|
|
if (!hasData($result))
|
|
return error($this->_ci->p->t(
|
|
'studierendenantrag',
|
|
'error_no_stdsem',
|
|
['studiensemester_kurzbz' => $antrag->studiensemester_kurzbz]
|
|
));
|
|
$asem = current(getData($result));
|
|
|
|
foreach ($stdsems as $sem) {
|
|
$result = $this->_ci->StudiensemesterModel->load($sem->studiensemester_kurzbz);
|
|
if (isError($result))
|
|
return $result;
|
|
if (hasData($result)) {
|
|
if (current(getData($result))->start < $asem->start) {
|
|
$stdsem = $sem->studiensemester_kurzbz;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// NOTE(chris): if we don't find a status in the previous semester there is something wrong
|
|
if (!$stdsem)
|
|
return error($this->_ci->p->t('studierendenantrag', 'error_no_status_in_prev_sem'));
|
|
|
|
$result = $this->getLvsByStgStsemAndSem(
|
|
$studiengang_kz,
|
|
$orgform_kurzbz,
|
|
$semA,
|
|
$ausbildungssemester - 1,
|
|
$antrag->prestudent_id,
|
|
$sprache
|
|
);
|
|
if (isError($result))
|
|
return $result;
|
|
|
|
$lvsA = getData($result) ?: [];
|
|
|
|
$result = $this->getLvsByStgStsemAndSem(
|
|
$studiengang_kz,
|
|
$orgform_kurzbz,
|
|
$stdsem,
|
|
$ausbildungssemester - 1,
|
|
$antrag->prestudent_id,
|
|
$sprache
|
|
);
|
|
if (isError($result))
|
|
return $result;
|
|
|
|
$lvsAtest = getData($result) ?: [];
|
|
|
|
if (count(array_intersect(array_map(function ($a) {
|
|
return $a->lehrveranstaltung_id;
|
|
}, $lvsA), array_map(function ($a) {
|
|
return $a->lehrveranstaltung_id;
|
|
}, $lvsAtest)))) {
|
|
foreach ($lvsA as $lv) {
|
|
if (isset($lvszugewiesen[$lv->lehrveranstaltung_id]) && ($lvszugewiesen[$lv->lehrveranstaltung_id]->note == 0)) {
|
|
$lv->antrag_anmerkung = $lvszugewiesen[$lv->lehrveranstaltung_id]->anmerkung;
|
|
$lv->antrag_zugelassen = true;
|
|
}
|
|
}
|
|
} else {
|
|
$lvsA = null;
|
|
}
|
|
}
|
|
|
|
$result = $this->getLvsByStgStsemAndSem(
|
|
$studiengang_kz,
|
|
$orgform_kurzbz,
|
|
$semB,
|
|
$ausbildungssemester,
|
|
$antrag->prestudent_id,
|
|
$sprache
|
|
);
|
|
if (isError($result))
|
|
return $result;
|
|
$lvsB = getData($result) ?: [];
|
|
foreach($lvsB as $lv)
|
|
{
|
|
if(isset($lvszugewiesen[$lv->lehrveranstaltung_id]) && ($lvszugewiesen[$lv->lehrveranstaltung_id]->note == 0))
|
|
{
|
|
$lv->antrag_anmerkung = $lvszugewiesen[$lv->lehrveranstaltung_id]->anmerkung;
|
|
$lv->antrag_zugelassen = true;
|
|
}
|
|
// TODO(manu): eventuelle Änderungen taggen
|
|
}
|
|
|
|
$result = [
|
|
'1' . $semA => $lvsA,
|
|
'2' . $semB => $lvsB ?: []
|
|
];
|
|
if ($repeat_last)
|
|
$result['repeat_last'] = true;
|
|
|
|
return success($result);
|
|
}
|
|
|
|
public function getLvsByStgStsemAndSem(
|
|
$studiengang_kz,
|
|
$orgform_kurzbz,
|
|
$studiensemester_kurzbz,
|
|
$ausbildungssemester,
|
|
$prestudent_id,
|
|
$sprache
|
|
) {
|
|
$this->_ci->load->model('organisation/Studienplan_model', 'StudienplanModel');
|
|
|
|
$result = $this->_ci->StudienplanModel->getStudienplaeneBySemester(
|
|
$studiengang_kz,
|
|
$studiensemester_kurzbz,
|
|
$ausbildungssemester,
|
|
$orgform_kurzbz
|
|
);
|
|
if (isError($result))
|
|
return $result;
|
|
$result = getData($result);
|
|
if (!$result) {
|
|
$result = $this->_ci->StudiengangModel->load($studiengang_kz);
|
|
if (isError($result))
|
|
return $result;
|
|
if (!hasData($result))
|
|
return error($this->_ci->p->t('studierendenantrag', 'error_no_stg', ['studiengang_kz' => $studiengang_kz]));
|
|
$stg = current(getData($result));
|
|
|
|
if ($ausbildungssemester > $stg->max_semester)
|
|
return success();
|
|
return error($this->_ci->p->t('studierendenantrag', 'error_no_studienplan', [
|
|
'studiengang_kz' => $studiengang_kz,
|
|
'studiensemester_kurzbz' => $studiensemester_kurzbz,
|
|
'semester' => $ausbildungssemester
|
|
]));
|
|
}
|
|
if (count($result) > 1) {
|
|
$langmap = array_unique(array_map(function ($a) {
|
|
return $a->sprache;
|
|
}, $result));
|
|
if ($sprache
|
|
&& count($langmap) == count($result)
|
|
&& in_array($sprache, $langmap)
|
|
) {
|
|
$result = array_filter($result, function ($a) use ($sprache) {
|
|
return $a->sprache == $sprache;
|
|
});
|
|
} else {
|
|
return error($this->_ci->p->t('studierendenantrag', 'error_multiple_studienplan', [
|
|
'studiengang_kz' => $studiengang_kz,
|
|
'studiensemester_kurzbz' => $studiensemester_kurzbz,
|
|
'semester' => $ausbildungssemester
|
|
]));
|
|
}
|
|
}
|
|
$studienplan = current($result);
|
|
|
|
return $this->_ci->StudienplanModel->getStudienplanLehrveranstaltungForPrestudent(
|
|
$studienplan->studienplan_id,
|
|
$ausbildungssemester,
|
|
$prestudent_id
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Checks if a prestudent can submit an Antrag for Abmeldung
|
|
*
|
|
* @param integer $prestudent_id
|
|
*
|
|
* @return \stdClass on success retval 0 means not a student;
|
|
* retval 1 means Berechtigt;
|
|
* retval -1 means has already an Antrag pending;
|
|
* retval -2 means other Antrag pending;
|
|
* retval -3 means in blacklist stg
|
|
*/
|
|
public function getPrestudentAbmeldeBerechtigt($prestudent_id)
|
|
{
|
|
$result = $this->_ci->PrestudentModel->load($prestudent_id);
|
|
if (isError($result))
|
|
return $result;
|
|
if (!hasData($result))
|
|
return success(0);
|
|
$result = current(getData($result));
|
|
$stg_kz = $result->studiengang_kz;
|
|
if (in_array($stg_kz, $this->_ci->config->item('stgkz_blacklist_abmeldung')))
|
|
return success(-3);
|
|
|
|
$result = $this->_ci->PrestudentstatusModel->getLastStatus($prestudent_id);
|
|
if (isError($result))
|
|
return $result;
|
|
if (!hasData($result))
|
|
return success(0);
|
|
$result = current(getData($result));
|
|
$datumStatus = $result->datum;
|
|
|
|
if (!in_array($result->status_kurzbz, $this->_ci->config->item('antrag_prestudentstatus_whitelist_abmeldung'))) {
|
|
$result = $this->_ci->StudierendenantragModel->loadWithStatusWhere([
|
|
'prestudent_id' => $prestudent_id,
|
|
's.studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_APPROVED
|
|
], [
|
|
Studierendenantrag_model::TYP_ABMELDUNG,
|
|
Studierendenantrag_model::TYP_ABMELDUNG_STGL
|
|
]);
|
|
if (isError($result))
|
|
return $result;
|
|
if (hasData($result))
|
|
return success(-1);
|
|
|
|
$result = $this->_ci->StudierendenantragModel->loadWithStatusWhere([
|
|
'prestudent_id' => $prestudent_id,
|
|
's.studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_PAUSE
|
|
], [
|
|
Studierendenantrag_model::TYP_ABMELDUNG,
|
|
Studierendenantrag_model::TYP_ABMELDUNG_STGL
|
|
]);
|
|
if (isError($result))
|
|
return $result;
|
|
if (hasData($result))
|
|
return success(-1);
|
|
|
|
return success(0);
|
|
}
|
|
|
|
$result = $this->_ci->StudierendenantragModel->loadWithStatusWhere(['prestudent_id' => $prestudent_id]);
|
|
if (isError($result))
|
|
return $result;
|
|
if (!hasData($result))
|
|
return success(1);
|
|
$result= getData($result);
|
|
foreach ($result as $antrag)
|
|
{
|
|
if ($antrag->typ == Studierendenantrag_model::TYP_ABMELDUNG || $antrag->typ == Studierendenantrag_model::TYP_ABMELDUNG_STGL)
|
|
{
|
|
if ($antrag->status == Studierendenantragstatus_model::STATUS_CREATED)
|
|
return success(-1);
|
|
elseif ($antrag->status == Studierendenantragstatus_model::STATUS_APPROVED && $antrag->datum > $datumStatus)
|
|
return success(-1);
|
|
}
|
|
if ($antrag->typ == Studierendenantrag_model::TYP_WIEDERHOLUNG)
|
|
{
|
|
if($antrag->status == Studierendenantragstatus_model::STATUS_PASS)
|
|
return success(-2);
|
|
}
|
|
}
|
|
|
|
return success(1);
|
|
}
|
|
|
|
/**
|
|
* Checks if a prestudent can submit an Antrag for Unterbrechung
|
|
*
|
|
* @param integer $prestudent_id
|
|
* @param string $studiensemester_kurzbz (optional)
|
|
*
|
|
* @return \stdClass on success retval 0 means not a student;
|
|
* retval 1 means Berechtigt;
|
|
* retval -1 means has already an Antrag pending;
|
|
* retval -2 means other Antrag pending;
|
|
* retval -3 means in blacklist stg
|
|
*/
|
|
public function getPrestudentUnterbrechungsBerechtigt($prestudent_id, $studiensemester_kurzbz = null, $datum_wiedereinstieg = null)
|
|
{
|
|
$result = $this->_ci->PrestudentModel->load($prestudent_id);
|
|
if (isError($result))
|
|
return $result;
|
|
if (!hasData($result))
|
|
return success(0);
|
|
$result = current(getData($result));
|
|
$stg_kz = $result->studiengang_kz;
|
|
if (in_array($stg_kz, $this->_ci->config->item('stgkz_blacklist_unterbrechung')))
|
|
return success(-3);
|
|
|
|
$result = $this->_ci->PrestudentstatusModel->getLastStatus($prestudent_id);
|
|
if (isError($result))
|
|
return $result;
|
|
if (!hasData($result))
|
|
return success(0);
|
|
$result = current(getData($result));
|
|
$prestudent_stdsem = $result->studiensemester_kurzbz;
|
|
$datumStatus = $result->datum;
|
|
if (!in_array($result->status_kurzbz, $this->_ci->config->item('antrag_prestudentstatus_whitelist'))
|
|
&& $result->status_kurzbz != 'Unterbrecher') {
|
|
return success(0);
|
|
}
|
|
$result = $this->_ci->StudierendenantragModel->loadWithStatusWhere(['prestudent_id' => $prestudent_id]);
|
|
if (isError($result))
|
|
return $result;
|
|
if (!hasData($result))
|
|
return success(1);
|
|
|
|
$result = getData($result);
|
|
foreach ($result as $antrag)
|
|
{
|
|
if ($antrag->typ == Studierendenantrag_model::TYP_ABMELDUNG || $antrag->typ == Studierendenantrag_model::TYP_ABMELDUNG_STGL)
|
|
{
|
|
if($antrag->status == Studierendenantragstatus_model::STATUS_CREATED)
|
|
return success(-2);
|
|
elseif($antrag->status == Studierendenantragstatus_model::STATUS_APPROVED && $antrag->datum > $datumStatus)
|
|
return success(-2);
|
|
}
|
|
if ($antrag->typ == Studierendenantrag_model::TYP_UNTERBRECHUNG)
|
|
{
|
|
// NOTE(chris): Ignore canceled ones
|
|
if ($antrag->status == Studierendenantragstatus_model::STATUS_CANCELLED)
|
|
continue;
|
|
}
|
|
if ($antrag->typ == Studierendenantrag_model::TYP_WIEDERHOLUNG)
|
|
{
|
|
if($antrag->status == Studierendenantragstatus_model::STATUS_PASS)
|
|
return success(-2);
|
|
}
|
|
}
|
|
|
|
if (!$studiensemester_kurzbz) {
|
|
$sems = $this->getSemesterForUnterbrechung($prestudent_id, $prestudent_stdsem);
|
|
if (!count(array_filter($sems, function ($item) {
|
|
return !$item['disabled'];
|
|
})))
|
|
return success(-1);
|
|
} else {
|
|
if ($this->_ci->StudierendenantragModel->hasRunningUnterbrechungBetween($prestudent_id, $studiensemester_kurzbz, $datum_wiedereinstieg))
|
|
return success(-1);
|
|
}
|
|
|
|
return success(1);
|
|
}
|
|
|
|
/**
|
|
* Checks if a prestudent can submit an Antrag for Wiederholung
|
|
*
|
|
* @param integer $prestudent_id
|
|
*
|
|
* @return \stdClass on success retval 0 means not a student;
|
|
* retval 1 means Berechtigt;
|
|
* retval -1 means has already an Antrag pending;
|
|
* retval -2 means other Antrag pending;
|
|
* retval -3 means in blacklist stg
|
|
*/
|
|
public function getPrestudentWiederholungsBerechtigt($prestudent_id)
|
|
{
|
|
$result = $this->_ci->PrestudentModel->load($prestudent_id);
|
|
if (isError($result))
|
|
return $result;
|
|
if (!hasData($result))
|
|
return success(0);
|
|
$result = current(getData($result));
|
|
$stg_kz = $result->studiengang_kz;
|
|
if (in_array($stg_kz, $this->_ci->config->item('stgkz_blacklist_wiederholung')))
|
|
return success(-3);
|
|
|
|
$result = $this->getFailedExamForPrestudent($prestudent_id);
|
|
if (isError($result))
|
|
return $result;
|
|
if (!hasData($result))
|
|
return success(0);
|
|
|
|
$result = $this->_ci->PrestudentstatusModel->getLastStatus($prestudent_id);
|
|
if (isError($result))
|
|
return $result;
|
|
if (!hasData($result))
|
|
return success(0);
|
|
|
|
$result = current(getData($result));
|
|
$datumStatus = $result->datum;
|
|
if (!in_array($result->status_kurzbz, $this->_ci->config->item('antrag_prestudentstatus_whitelist'))) {
|
|
$result = $this->_ci->StudierendenantragModel->loadWithStatusWhere([
|
|
'prestudent_id' => $prestudent_id,
|
|
'typ' => Studierendenantrag_model::TYP_WIEDERHOLUNG,
|
|
's.studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_APPROVED
|
|
]);
|
|
if (isError($result))
|
|
return $result;
|
|
if (hasData($result))
|
|
return success(-1);
|
|
|
|
$result = $this->_ci->StudierendenantragModel->loadWithStatusWhere([
|
|
'prestudent_id' => $prestudent_id,
|
|
'typ' => Studierendenantrag_model::TYP_WIEDERHOLUNG,
|
|
's.studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_DEREGISTERED
|
|
]);
|
|
if (isError($result))
|
|
return $result;
|
|
if (hasData($result))
|
|
return success(-1);
|
|
|
|
$result = $this->_ci->StudierendenantragModel->loadWithStatusWhere([
|
|
'prestudent_id' => $prestudent_id,
|
|
'typ' => Studierendenantrag_model::TYP_WIEDERHOLUNG,
|
|
's.studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_PAUSE
|
|
]);
|
|
if (isError($result))
|
|
return $result;
|
|
if (hasData($result))
|
|
return success(-1);
|
|
|
|
return success(0);
|
|
}
|
|
$result = $this->_ci->StudierendenantragModel->loadWithStatusWhere(['prestudent_id' => $prestudent_id]);
|
|
if (isError($result))
|
|
return $result;
|
|
if (!hasData($result))
|
|
return success(1);
|
|
$result= getData($result);
|
|
foreach ($result as $antrag)
|
|
{
|
|
if ($antrag->typ == Studierendenantrag_model::TYP_ABMELDUNG || $antrag->typ == Studierendenantrag_model::TYP_ABMELDUNG_STGL)
|
|
{
|
|
if($antrag->status == Studierendenantragstatus_model::STATUS_CREATED)
|
|
return success(-2);
|
|
elseif($antrag->status == Studierendenantragstatus_model::STATUS_APPROVED && $antrag->datum > $datumStatus)
|
|
return success(-2);
|
|
}
|
|
if ($antrag->typ == Studierendenantrag_model::TYP_WIEDERHOLUNG)
|
|
{
|
|
return success(-1);
|
|
}
|
|
}
|
|
|
|
return success(1);
|
|
}
|
|
|
|
/**
|
|
* Gets details for a new Antrag
|
|
*
|
|
* @param integer $prestudent_id
|
|
*
|
|
* @return \stdClass
|
|
*/
|
|
public function getDetailsForNewAntrag($prestudent_id)
|
|
{
|
|
$result = $this->_ci->PrestudentstatusModel->loadLastWithStgDetails($prestudent_id);
|
|
if (isError($result))
|
|
return $result;
|
|
if (!hasData($result))
|
|
return error($this->_ci->p->t('studierendenantrag', 'error_no_prestudentstatus', ['prestudent_id' => $prestudent_id]));
|
|
$result = current(getData($result));
|
|
return success($result);
|
|
}
|
|
|
|
public function getDetailsForLastAntrag($prestudent_id, $typ = null)
|
|
{
|
|
$result = $this->_ci->PrestudentstatusModel->loadLastWithStgDetails($prestudent_id);
|
|
if (isError($result))
|
|
return $result;
|
|
if (!hasData($result))
|
|
return error($this->_ci->p->t('studierendenantrag', 'error_no_prestudentstatus', ['prestudent_id' => $prestudent_id]));
|
|
$resultDetails = current(getData($result));
|
|
|
|
$where = [
|
|
'prestudent_id' => $prestudent_id
|
|
];
|
|
$types = null;
|
|
if ($typ) {
|
|
if (is_array($typ))
|
|
$types = $typ;
|
|
else
|
|
$where['typ'] = $typ;
|
|
}
|
|
$result = $this->_ci->StudierendenantragModel->loadWithStatusWhere($where, $types);
|
|
if (isError($result))
|
|
return $result;
|
|
|
|
$antraege = getData($result) ?: [];
|
|
$resultAntrag = null;
|
|
foreach ($antraege as $antrag) {
|
|
if ($antrag->status != Studierendenantragstatus_model::STATUS_CANCELLED) {
|
|
$resultAntrag = $antrag;
|
|
break;
|
|
}
|
|
}
|
|
if (!$resultAntrag)
|
|
return error($this->_ci->p->t('studierendenantrag', 'error_no_antrag_found_prestudent', [
|
|
'typ' => $typ ?: '',
|
|
'prestudent_id' => $prestudent_id
|
|
]));
|
|
|
|
$resultDetails->status = $resultAntrag->status;
|
|
$resultDetails->statustyp = $resultAntrag->statustyp;
|
|
$resultDetails->status_insertvon = $resultAntrag->status_insertvon;
|
|
$resultDetails->grund = $resultAntrag->grund;
|
|
$resultDetails->studierendenantrag_id = $resultAntrag->studierendenantrag_id;
|
|
$resultDetails->typ = $resultAntrag->typ;
|
|
$resultDetails->datum = $resultAntrag->datum;
|
|
$resultDetails->studiensemester_kurzbz = $resultAntrag->studiensemester_kurzbz;
|
|
|
|
return success($resultDetails);
|
|
}
|
|
|
|
public function getDetailsForAntrag($studierendenantrag_id)
|
|
{
|
|
$where = [
|
|
's.studierendenantrag_id' => $studierendenantrag_id
|
|
];
|
|
|
|
$result = $this->_ci->StudierendenantragModel->loadWithStatusWhere($where);
|
|
if (isError($result))
|
|
return $result;
|
|
|
|
if (!hasData($result))
|
|
return error($this->_ci->p->t('studierendenantrag', "error_no_antrag_found", ['id' => $studierendenantrag_id]));
|
|
$resultAntrag = current(getData($result));
|
|
|
|
$result = $this->_ci->PrestudentstatusModel->loadLastWithStgDetails($resultAntrag->prestudent_id, $resultAntrag->studiensemester_kurzbz);
|
|
if (isError($result))
|
|
return $result;
|
|
if (!hasData($result)) {
|
|
$result = $this->_ci->PrestudentstatusModel->loadLastWithStgDetails($resultAntrag->prestudent_id);
|
|
if (isError($result))
|
|
return $result;
|
|
if (!hasData($result))
|
|
return error($this->_ci->p->t('studierendenantrag', 'error_no_prestudentstatus', $resultAntrag));
|
|
}
|
|
$resultDetails = current(getData($result));
|
|
|
|
$resultDetails->status = $resultAntrag->status;
|
|
$resultDetails->statustyp = $resultAntrag->statustyp;
|
|
$resultDetails->grund = $resultAntrag->grund;
|
|
$resultDetails->studierendenantrag_id = $resultAntrag->studierendenantrag_id;
|
|
$resultDetails->typ = $resultAntrag->typ;
|
|
$resultDetails->dms_id = $resultAntrag->dms_id;
|
|
$resultDetails->datum_wiedereinstieg = $resultAntrag->datum_wiedereinstieg;
|
|
|
|
return success($resultDetails);
|
|
}
|
|
|
|
/**
|
|
* Rearrange the free semester slots for a new Unterbrechung
|
|
*
|
|
* @param integer $prestudent_id
|
|
* @param string $studiensemester_kurzbz
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getSemesterForUnterbrechung($prestudent_id, $studiensemester_kurzbz)
|
|
{
|
|
$result = $this->_ci->StudierendenantragModel->getFreeSlotsForUnterbrechung($prestudent_id, $studiensemester_kurzbz);
|
|
if (isError($result))
|
|
return [];
|
|
$result = getData($result);
|
|
if (!$result)
|
|
return [];
|
|
return array_reduce($result, function ($carry, $item) {
|
|
if (!isset($carry[$item->von]))
|
|
$carry[$item->von] = [
|
|
'studiensemester_kurzbz' => $item->von,
|
|
'wiedereinstieg' => [],
|
|
'disabled' => true
|
|
];
|
|
|
|
$carry[$item->von]['wiedereinstieg'][] = [
|
|
'studiensemester_kurzbz' => $item->bis,
|
|
'start' => $item->ende,
|
|
'disabled' => (boolean)$item->studierendenantrag_id
|
|
];
|
|
|
|
if ($carry[$item->von]['disabled'] && !$item->studierendenantrag_id) {
|
|
$carry[$item->von]['disabled'] = false;
|
|
}
|
|
|
|
return $carry;
|
|
}, []);
|
|
return $result;
|
|
}
|
|
|
|
public function getAktivePrestudentenInStgs($studiengaenge, $query)
|
|
{
|
|
$blacklist = $this->_ci->config->item('stgkz_blacklist_abmeldung');
|
|
$studiengaenge = array_diff($studiengaenge, $blacklist);
|
|
return $this->_ci->StudiengangModel->getAktivePrestudenten(
|
|
$studiengaenge,
|
|
[ Studierendenantrag_model::TYP_ABMELDUNG ],
|
|
$query
|
|
);
|
|
}
|
|
|
|
public function getFailedExamForPrestudent($prestudent_id, $max_date = null, $studiensemester_kurzbz = null)
|
|
{
|
|
return $this->_ci->PruefungModel->loadWhereCommitteeExamFailedForPrestudent($prestudent_id, $max_date, $studiensemester_kurzbz);
|
|
}
|
|
|
|
public function saveLvs($lvArray)
|
|
{
|
|
$result = $this->_ci->StudierendenantraglehrveranstaltungModel->deleteWhere([
|
|
'studierendenantrag_id' => $lvArray[0]['studierendenantrag_id']
|
|
]);
|
|
if (isError($result))
|
|
return $result;
|
|
|
|
$result = $this->_ci->StudierendenantraglehrveranstaltungModel->insertBatch($lvArray);
|
|
if (isError($result))
|
|
return $result;
|
|
|
|
$result = $this->_ci->StudierendenantragstatusModel->insert([
|
|
'studierendenantrag_id' => $lvArray[0]['studierendenantrag_id'],
|
|
'studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_LVSASSIGNED,
|
|
'insertvon' => $lvArray[0]['insertvon']
|
|
]);
|
|
if (isError($result))
|
|
return $result;
|
|
|
|
$antrag_status_id = getData($result);
|
|
$result = $this->_ci->StudierendenantragstatusModel->loadWithTyp($antrag_status_id);
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function approveWiederholung($antrag_id, $insertvon)
|
|
{
|
|
$this->_ci->load->model('crm/Student_model', 'StudentModel');
|
|
|
|
$result = $this->_ci->StudierendenantragstatusModel->insert([
|
|
'studierendenantrag_id' => $antrag_id,
|
|
'studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_APPROVED,
|
|
'insertvon' => $insertvon
|
|
]);
|
|
|
|
if (isError($result)) {
|
|
return $result;
|
|
}
|
|
|
|
$result = $this->_ci->StudierendenantragModel->getStgEmail($antrag_id);
|
|
if (isError($result))
|
|
return $result;
|
|
$result = getData($result);
|
|
if (!$result)
|
|
return error($this->_ci->p->t('studierendenantrag', 'error_no_stg_email', ['id' => $antrag_id]));
|
|
|
|
$email = current($result)->email;
|
|
|
|
$result = $this->_ci->StudierendenantragModel->getStgAndSem($antrag_id);
|
|
if (isError($result))
|
|
return $result;
|
|
$result = getData($result);
|
|
if (!$result)
|
|
return error($this->_ci->p->t('studierendenantrag', 'error_no_stg_antrag', ['id' => $antrag_id]));
|
|
|
|
$stg = current($result);
|
|
$semester = $stg->ausbildungssemester;
|
|
|
|
$result = $this->_ci->StudierendenantragModel->load($antrag_id);
|
|
if (isError($result))
|
|
return $result;
|
|
if (!hasData($result))
|
|
return error($this->_ci->p->t('studierendenantrag', 'error_no_antrag_found', ['id' => $antrag_id]));
|
|
$result = current(getData($result));
|
|
$prestudent_id = $result->prestudent_id;
|
|
|
|
$result = $this->_ci->PersonModel->loadPrestudent($prestudent_id);
|
|
if (isError($result))
|
|
return $result;
|
|
if (!hasData($result))
|
|
return error($this->_ci->p->t('studierendenantrag', 'error_no_person_prestudent', ['prestudent_id' => $prestudent_id]));
|
|
$person = current(getData($result));
|
|
$student = trim($person->vorname . ' ' . $person->nachname);
|
|
|
|
$result = $this->_ci->PersonModel->getFullName($insertvon);
|
|
if (isError($result))
|
|
return $result;
|
|
$mitarbeiter = $insertvon;
|
|
if (hasData($result)) {
|
|
$mitarbeiter = getData($result);
|
|
}
|
|
|
|
$result = $this->_ci->StudentModel->loadWhere(['prestudent_id'=> $prestudent_id]);
|
|
if (hasData($result)) {
|
|
$studentObj = current(getData($result));
|
|
$student_uid = $studentObj->student_uid;
|
|
}
|
|
else
|
|
$student_uid = '';
|
|
|
|
// NOTE(chris): Sancho mail
|
|
if (!sendSanchoMail(
|
|
'Sancho_Mail_Antrag_W_Approve',
|
|
[
|
|
'antrag_id' => $antrag_id,
|
|
'stg' => $stg->bezeichnung,
|
|
'sem' => $semester,
|
|
'student' => $student,
|
|
'mitarbeiter' => $mitarbeiter,
|
|
'Orgform' => $stg->orgform_kurzbz,
|
|
'UID' => $student_uid
|
|
],
|
|
$email,
|
|
$this->_ci->p->t('studierendenantrag', 'mail_subject_W_Approve')
|
|
))
|
|
return error($this->_ci->p->t('studierendenantrag', 'error_mail_to', ['email' => $email]));
|
|
|
|
if ($student_uid) {
|
|
$email = $this->_ci->StudentModel->getEmailFH($student_uid);
|
|
$vorlage = 'Sancho_Mail_Antrag_W_Student';
|
|
|
|
$sem_not_allowed = $sem_to_repeat = '';
|
|
$list_not_allowed = $list_to_repeat = $this->_ci->p->t('studierendenantrag', 'mail_part_error_no_lvs');
|
|
|
|
$result = $this->getLvsForAntrag($antrag_id);
|
|
if (hasData($result)) {
|
|
$lvs = getData($result);
|
|
if (isset($lvs['repeat_last'])) {
|
|
unset($lvs['repeat_last']);
|
|
$vorlage .= '_Lst';
|
|
}
|
|
foreach ($lvs as $sem => $lv_list) {
|
|
$lvs_filtered = array_filter($lv_list, function ($el) {
|
|
return property_exists($el, 'antrag_zugelassen') && $el->antrag_zugelassen;
|
|
});
|
|
if (substr($sem, 0, 1) == '1') {
|
|
$sem_not_allowed = substr($sem, 1);
|
|
$list_not_allowed = array_map(function ($el) {
|
|
return $el->bezeichnung . '(' . $el->lehrform_kurzbz . ')';
|
|
}, $lvs_filtered);
|
|
$list_not_allowed = '<ul><li>' . implode('</li><li>', $list_not_allowed) . '</li></ul>';
|
|
} else {
|
|
$sem_to_repeat = substr($sem, 1);
|
|
$list_to_repeat = array_map(function ($el) {
|
|
return $el->bezeichnung . '(' . $el->lehrform_kurzbz . ')';
|
|
}, $lvs_filtered);
|
|
$list_to_repeat = '<ul><li>' . implode('</li><li>', $list_to_repeat) . '</li></ul>';
|
|
}
|
|
}
|
|
}
|
|
|
|
// NOTE(chris): Sancho mail
|
|
sendSanchoMail(
|
|
$vorlage,
|
|
[
|
|
'antrag_id' => $antrag_id,
|
|
'stg' => $stg->bezeichnung,
|
|
'sem' => $semester,
|
|
'mitarbeiter' => $mitarbeiter,
|
|
'student' => $student,
|
|
'sem_not_allowed' => $sem_not_allowed,
|
|
'list_not_allowed' => $list_not_allowed,
|
|
'sem_to_repeat' => $sem_to_repeat,
|
|
'list_to_repeat' => $list_to_repeat,
|
|
'Orgform' => $stg->orgform_kurzbz
|
|
],
|
|
$email,
|
|
$this->_ci->p->t('studierendenantrag', 'mail_subject_W_Student')
|
|
);
|
|
}
|
|
|
|
|
|
return success();
|
|
}
|
|
|
|
public function getAntragHistory($antrag_id)
|
|
{
|
|
$result = $this->_ci->StudierendenantragstatusModel->loadWithTypWhere([
|
|
'studierendenantrag_id' => $antrag_id
|
|
]);
|
|
return $result;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param integer $studierendenantrag_id
|
|
*
|
|
* @return boolean
|
|
*/
|
|
protected function isOwnAntrag($studierendenantrag_id)
|
|
{
|
|
if ($studierendenantrag_id == null)
|
|
return false;
|
|
$result = $this->_ci->StudierendenantragModel->loadForPerson(getAuthPersonId());
|
|
if (!hasData($result))
|
|
return false;
|
|
$antraege = array_map(function ($antrag) {
|
|
return $antrag->studierendenantrag_id;
|
|
}, getData($result));
|
|
|
|
return in_array($studierendenantrag_id, $antraege);
|
|
}
|
|
|
|
/**
|
|
* @param integer $studierendenantrag_id
|
|
* @param string $permission either 'student/antragfreigabe' or 'student/studierendenantrag'
|
|
*
|
|
* @return boolean
|
|
*/
|
|
protected function hasAccessToAntrag($studierendenantrag_id, $permission)
|
|
{
|
|
$studiengaenge = $this->_ci->permissionlib->getSTG_isEntitledFor($permission);
|
|
if (!$studiengaenge)
|
|
return false;
|
|
$result = $this->_ci->StudierendenantragModel->isInStudiengang($studierendenantrag_id, $studiengaenge);
|
|
return (boolean)getData($result);
|
|
}
|
|
|
|
/**
|
|
* @param integer $antrag_id
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function isEntitledToShowAntrag($antrag_id)
|
|
{
|
|
return
|
|
(
|
|
$this->isOwnAntrag($antrag_id) ||
|
|
$this->hasAccessToAntrag($antrag_id, 'student/antragfreigabe') ||
|
|
$this->hasAccessToAntrag($antrag_id, 'student/studierendenantrag')
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @param integer $antrag_id
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function isEntitledToSeeHistoryForAntrag($antrag_id)
|
|
{
|
|
return
|
|
(
|
|
$this->isOwnAntrag($antrag_id) ||
|
|
$this->hasAccessToAntrag($antrag_id, 'student/antragfreigabe') ||
|
|
$this->hasAccessToAntrag($antrag_id, 'student/studierendenantrag')
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @param integer $prestudent_id
|
|
* @param boolean $checkAssistencePermission
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function isEntitledToCreateAntragFor($prestudent_id, $checkAssistencePermission = false)
|
|
{
|
|
$result = $this->_ci->PrestudentModel->load($prestudent_id);
|
|
if (!hasData($result))
|
|
return false;
|
|
|
|
$result = getData($result)[0];
|
|
$person_id = $result->person_id;
|
|
|
|
if (getAuthPersonId() == $person_id)
|
|
return true;
|
|
|
|
if ($checkAssistencePermission)
|
|
{
|
|
$studiengaenge = $this->_ci->permissionlib->getSTG_isEntitledFor('student/studierendenantrag');
|
|
if (in_array($result->studiengang_kz, $studiengaenge ?: []))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @param integer $antrag_id
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function isEntitledToCancelAntrag($antrag_id)
|
|
{
|
|
$result = $this->_ci->StudierendenantragModel->load($antrag_id);
|
|
if (!hasData($result))
|
|
return false;
|
|
$antrag = current(getData($result));
|
|
|
|
if ($antrag->typ != Studierendenantrag_model::TYP_ABMELDUNG_STGL)
|
|
return $this->isOwnAntrag($antrag_id);
|
|
|
|
return $this->hasAccessToAntrag($antrag_id, 'student/studierendenantrag');
|
|
}
|
|
|
|
/**
|
|
* @param integer $antrag_id
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function isEntitledToPauseAntrag($antrag_id)
|
|
{
|
|
return ($this->hasAccessToAntrag($antrag_id, 'student/antragfreigabe') || $this->hasAccessToAntrag($antrag_id, 'student/studierendenantrag'));
|
|
}
|
|
|
|
/**
|
|
* @param integer $antrag_id
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function isEntitledToUnpauseAntrag($antrag_id)
|
|
{
|
|
return $this->hasAccessToAntrag($antrag_id, 'student/studierendenantrag');
|
|
}
|
|
|
|
/**
|
|
* @param integer $antrag_id
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function isEntitledToReopenAntrag($antrag_id)
|
|
{
|
|
return $this->hasAccessToAntrag($antrag_id, 'student/studierendenantrag');
|
|
}
|
|
|
|
/**
|
|
* @param integer $antrag_id
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function isEntitledToObjectAntrag($antrag_id)
|
|
{
|
|
return ($this->hasAccessToAntrag($antrag_id, 'student/antragfreigabe') || $this->hasAccessToAntrag($antrag_id, 'student/studierendenantrag'));
|
|
}
|
|
|
|
/**
|
|
* @param integer $antrag_id
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function isEntitledToApproveAntrag($antrag_id)
|
|
{
|
|
return $this->hasAccessToAntrag($antrag_id, 'student/antragfreigabe');
|
|
}
|
|
|
|
/**
|
|
* @param integer $antrag_id
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function isEntitledToRejectAntrag($antrag_id)
|
|
{
|
|
return $this->hasAccessToAntrag($antrag_id, 'student/antragfreigabe');
|
|
}
|
|
|
|
/**
|
|
* @param integer $antrag_id
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function antragCanBeManualPaused($antrag_id)
|
|
{
|
|
$this->_ci->StudierendenantragModel->db->where_not_in('campus.get_status_studierendenantrag(studierendenantrag_id)', [
|
|
Studierendenantragstatus_model::STATUS_DEREGISTERED,
|
|
Studierendenantragstatus_model::STATUS_APPROVED,
|
|
Studierendenantragstatus_model::STATUS_PAUSE
|
|
]);
|
|
$result = $this->_ci->StudierendenantragModel->loadWhere([
|
|
'studierendenantrag_id' => $antrag_id,
|
|
'typ' => Studierendenantrag_model::TYP_WIEDERHOLUNG
|
|
]);
|
|
|
|
return hasData($result);
|
|
}
|
|
|
|
/**
|
|
* @param integer $antrag_id
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function antragCanBeManualUnpaused($antrag_id)
|
|
{
|
|
return $this->_ci->StudierendenantragModel->isManuallyPaused($antrag_id);
|
|
}
|
|
|
|
/**
|
|
* @param integer $antrag_id
|
|
* @param string|array $status
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function hasStatus($antrag_id, $status)
|
|
{
|
|
$result = $this->_ci->StudierendenantragModel->getWithLastStatusWhere(['s.studierendenantrag_id' => $antrag_id]);
|
|
if (!hasData($result))
|
|
return false;
|
|
$lastStatus = getData($result)[0];
|
|
|
|
if (!is_array($status))
|
|
$status = [$status];
|
|
|
|
return in_array($lastStatus->studierendenantrag_statustyp_kurzbz, $status);
|
|
}
|
|
|
|
/**
|
|
* @param integer $antrag_id
|
|
* @param string|array $type
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function hasType($antrag_id, $type)
|
|
{
|
|
$result = $this->_ci->StudierendenantragModel->load($antrag_id);
|
|
if (!hasData($result))
|
|
return false;
|
|
$antrag = getData($result)[0];
|
|
|
|
if (!is_array($type))
|
|
$type = [$type];
|
|
|
|
return in_array($antrag->typ, $type);
|
|
}
|
|
|
|
|
|
/**
|
|
* @param integer $antrag_id
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function getLvsForPrestudent($prestudent_id, $studiensemester_kurzbz)
|
|
{
|
|
$result = $this->_ci->StudierendenantraglehrveranstaltungModel->getLvsForPrestudent($prestudent_id, $studiensemester_kurzbz);
|
|
return $result;
|
|
}
|
|
}
|