mirror of
https://github.com/FH-Complete/FHC-Core.git
synced 2026-06-01 20:29:29 +00:00
cgfhtw
1495 lines
45 KiB
PHP
1495 lines
45 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
|
|
]);
|
|
|
|
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("Kein Prestudent gefunden: " . $prestudent_id);
|
|
|
|
$prestudent = getData($result)[0];
|
|
if($prestudent->person_id == getAuthPersonId())
|
|
$status = Studierendenantragstatus_model::STATUS_CREATED;
|
|
else
|
|
$status = Studierendenantragstatus_model::STATUS_CREATED_STGL;
|
|
|
|
$result = $this->_ci->StudierendenantragModel->insert([
|
|
'prestudent_id' => $prestudent_id,
|
|
'studiensemester_kurzbz'=> $studiensemester_kurzbz,
|
|
'datum' => date('c'),
|
|
'typ' => Studierendenantrag_model::TYP_ABMELDUNG,
|
|
'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' => $status,
|
|
'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)
|
|
{
|
|
$errors = [];
|
|
foreach ($studierendenantrag_ids as $studierendenantrag_id) {
|
|
|
|
$result = $this->_ci->StudierendenantragModel->loadIdAndStatusWhere(['studierendenantrag_id' => $studierendenantrag_id]);
|
|
if (isError($result))
|
|
{
|
|
$errors[] = getError($result);
|
|
continue;
|
|
}
|
|
if(!hasData($result))
|
|
{
|
|
$errors[] = 'no Antrag found for '. $studierendenantrag_id;
|
|
continue;
|
|
}
|
|
$status = getData($result)[0];
|
|
|
|
if($status->status == Studierendenantragstatus_model::STATUS_CREATED_STGL)
|
|
{
|
|
$status_approved = Studierendenantragstatus_model::STATUS_APPROVED_STGL;
|
|
}
|
|
else
|
|
$status_approved = Studierendenantragstatus_model::STATUS_APPROVED;
|
|
|
|
$result = $this->_ci->StudierendenantragstatusModel->insert([
|
|
'studierendenantrag_id' => $studierendenantrag_id,
|
|
'studierendenantrag_statustyp_kurzbz' => $status_approved,
|
|
'insertvon' => $insertvon
|
|
]);
|
|
if (isError($result))
|
|
$errors[] = getError($result);
|
|
else {
|
|
$resultPrestudent = $this->_ci->StudierendenantragModel->load($studierendenantrag_id);
|
|
if (isError($resultPrestudent))
|
|
{
|
|
$errors[] = getError($resultPrestudent);
|
|
continue;
|
|
}
|
|
if ($status_approved == Studierendenantragstatus_model::STATUS_APPROVED)
|
|
{
|
|
$antrag = getData($resultPrestudent)[0];
|
|
|
|
$resultPrestudentStatus = $this->_ci->PrestudentstatusModel->getLastStatusWithStgEmail($antrag->prestudent_id);
|
|
if (isError($resultPrestudentStatus))
|
|
$errors[] = getError($resultPrestudentStatus);
|
|
|
|
else {
|
|
$prestudent_status = getData($resultPrestudentStatus)[0];
|
|
|
|
$vorlage ='Sancho_Mail_Antrag_A_Approve';
|
|
$subject = 'Abmeldung freigegeben';
|
|
|
|
$result = $this->_ci->prestudentlib->setAbbrecher($antrag->prestudent_id, $antrag->studiensemester_kurzbz, $insertvon);
|
|
if (isError($result))
|
|
{
|
|
$errors[] = getError($result);
|
|
return $errors;
|
|
}
|
|
|
|
$result = $this->_ci->PersonModel->loadPrestudent($antrag->prestudent_id);
|
|
$data = [
|
|
'nameStudent' => 'Student*in'
|
|
];
|
|
if (hasData($result)) {
|
|
$person = current(getData($result));
|
|
$data['nameStudent'] = trim($person->vorname . ' ' . $person->nachname);
|
|
}
|
|
// NOTE(chris): Sancho mail
|
|
sendSanchoMail($vorlage, $data, $prestudent_status->email, $subject);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (count($errors))
|
|
return error(implode(',', $errors));
|
|
|
|
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');
|
|
|
|
$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] = 'Could not approve Unterbrechung for studierendenantrag_id: ' .
|
|
$studierendenantrag_id .
|
|
'<br>Details:<br>' .
|
|
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('No antrag found with 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 = 'Unterbrechung freigegeben';
|
|
$mail = [];
|
|
|
|
if (isset($data['errors']['person_id']))
|
|
{
|
|
//send assistenz mit id
|
|
$errors[] = 'Mail to student not sent and student name not found<br>Details:<br>' . $data['errors']['person_id'];
|
|
$mail['ass'] = 'Student/in (' . $data['antrag']->prestudent_id . ')';
|
|
}
|
|
elseif (isset($data['errors']['email']))
|
|
{
|
|
if (isset($data['errors']['person']))
|
|
{
|
|
//send assistenz mit id
|
|
$errors[] = 'Mail to student not sent and student name not found<br>Details:<br>' .
|
|
$data['errors']['email'] .
|
|
'<br>' .
|
|
$data['errors']['person'];
|
|
$mail['ass'] = 'Student/in (' . $data['antrag']->prestudent_id . ')';
|
|
}
|
|
else
|
|
{
|
|
//send assistenz mit name
|
|
$errors[] = 'Mail to student not sent<br>Details:<br>' . $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[] = 'Student name not found<br>Details:<br>' . $data['errors']['person'];
|
|
$mail['ass'] = 'Student/in (' . $data['antrag']->prestudent_id . ')';
|
|
$mail['stu'] = 'Student/in';
|
|
}
|
|
else
|
|
{
|
|
//send normal
|
|
$mail['ass'] = $mail['stu'] = trim($data['person']->vorname . ' ' . $data['person']->nachname);
|
|
}
|
|
}
|
|
$mailVorlage = 'Sancho_Mail_Antrag_U_Approve';
|
|
if ($data['studienbeitrag'])
|
|
$mailVorlage .= '_SB';
|
|
if (isset($mail['ass'])) {
|
|
// NOTE(chris): Sancho mail
|
|
if (!sendSanchoMail(
|
|
$mailVorlage,
|
|
[
|
|
'name' => $mail['ass']
|
|
],
|
|
$data['prestudent_status']->email,
|
|
$subject
|
|
)) {
|
|
$errors[] = 'Failed to send email to ' . $data['prestudent_status']->email;
|
|
}
|
|
}
|
|
if (isset($mail['stu'])) {
|
|
// NOTE(chris): Sancho mail
|
|
if (!sendSanchoMail(
|
|
$mailVorlage,
|
|
[
|
|
'name' => $mail['stu']
|
|
],
|
|
$data['email'],
|
|
$subject
|
|
)) {
|
|
$errors[] = 'Failed to send email to ' . $data['email'];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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');
|
|
|
|
$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 reject 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_REJECTED,
|
|
'insertvon' => $insertvon,
|
|
'grund' => $grund
|
|
]);
|
|
if (isError($result)) {
|
|
$errors['failed_' . $studierendenantrag_id] = 'Could not reject Unterbrechung for studierendenantrag_id: ' .
|
|
$studierendenantrag_id .
|
|
'<br>Details:<br>' .
|
|
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 = 'Mail to student not sent<br>Details:<br>' . implode('<br>', $error_msg);
|
|
$errors[] = $error_msg;
|
|
} else {
|
|
if (isset($data['errors']['person'])) {
|
|
//send student mit "Student/in"
|
|
$errors[] = 'Student name not found<br>Details:<br>' . $data['errors']['person'];
|
|
$name = 'Student/in';
|
|
} else {
|
|
//send normal
|
|
$name = trim($data['person']->vorname . ' ' . $data['person']->nachname);
|
|
}
|
|
}
|
|
if ($name)
|
|
// NOTE(chris): Sancho mail
|
|
if (!sendSanchoMail(
|
|
'Sancho_Mail_Antrag_U_Reject',
|
|
[
|
|
'name' => $name,
|
|
'grund' => $grund,
|
|
'abmeldungLink' => site_url('lehre/Studierendenantrag/abmeldung/' . $data['prestudent_status']->prestudent_id)
|
|
],
|
|
$data['email'],
|
|
'Unterbrechung abgelehnt'
|
|
))
|
|
$errors[] = 'Failed to send email to ' . $data['email'];
|
|
}
|
|
}
|
|
}
|
|
|
|
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('No Studierendenantrag found for studierendenantrag_id: ' . $studierendenantrag_id);
|
|
|
|
$result['antrag'] = $antrag = current($res);
|
|
|
|
|
|
$res = $this->_ci->PrestudentstatusModel->getLastStatusWithStgEmail($antrag->prestudent_id);
|
|
if (isError($res))
|
|
return $res;
|
|
|
|
$res = getData($res);
|
|
if (!$res)
|
|
return error('No Prestudentstatus found for prestudent_id: ' . $antrag->prestudent_id);
|
|
|
|
$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'] = 'No Prestudent found for prestudent_id: ' . $antrag->prestudent_id;
|
|
} 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'] = 'No Person found for person_id: ' . $person_id;
|
|
} else {
|
|
$result['person'] = current($res);
|
|
}
|
|
}
|
|
|
|
$res = $this->_ci->KontaktModel->getZustellKontakt($person_id, ['email']);
|
|
if (isError($res)) {
|
|
$errors['email'] = getError($res);
|
|
} else {
|
|
$res = getData($res);
|
|
|
|
if (!$res) {
|
|
$errors['email'] = 'No email contact found for person_id: ' . $person_id;
|
|
} else {
|
|
$result['email'] = current($res)->kontakt;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
$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('Antrag bereits vorhanden!');
|
|
}
|
|
}
|
|
|
|
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('No Prestudentstatus found for prestudent_id: ' . $prestudent_id);
|
|
|
|
$prestudent_status = current($res);
|
|
$email = $prestudent_status->email;
|
|
// NOTE(chris): Sancho mail
|
|
sendSanchoMail(
|
|
'Sancho_Mail_Antrag_W_New',
|
|
[
|
|
'antrag_id' => $antrag_id,
|
|
'lvzuweisungLink' => site_url('lehre/Antrag/Wiederholung/assistenz/' . $antrag_id)
|
|
],
|
|
$email,
|
|
'Neue*r Wiederholer*in'
|
|
);
|
|
}
|
|
|
|
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('No antrag found with 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('No studiengang and ausbildungssemester found for antrag with id: ' . $antrag_id);
|
|
$result = current($result);
|
|
$studiengang_kz = $result->studiengang_kz;
|
|
$orgform_kurzbz = $result->orgform_kurzbz;
|
|
$ausbildungssemester = $result->ausbildungssemester;
|
|
|
|
// 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('No studiensemster found after: ' . $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('No studiensemster found after: ' . $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,
|
|
$antrag->studiensemester_kurzbz
|
|
);
|
|
if (isError($result))
|
|
return $result;
|
|
$lvsA = $result->retval; // NOTE(chris): don't use getData() because we want to differenciate [] and null
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
$result = $this->getLvsByStgStsemAndSem(
|
|
$studiengang_kz,
|
|
$orgform_kurzbz,
|
|
$semB,
|
|
$ausbildungssemester,
|
|
$antrag->prestudent_id,
|
|
$antrag->studiensemester_kurzbz
|
|
);
|
|
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
|
|
}
|
|
|
|
return success([
|
|
'1' . $semA => $lvsA,
|
|
'2' . $semB => $lvsB ?: []
|
|
]);
|
|
}
|
|
|
|
public function getLvsByStgStsemAndSem(
|
|
$studiengang_kz,
|
|
$orgform_kurzbz,
|
|
$studiensemester_kurzbz,
|
|
$ausbildungssemester,
|
|
$prestudent_id,
|
|
$note_stsem
|
|
) {
|
|
$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('No Studiengang found with studiengang_kz: ' . $studiengang_kz);
|
|
$stg = current(getData($result));
|
|
|
|
if ($ausbildungssemester > $stg->max_semester)
|
|
return success();
|
|
return error('No studienplan found for stg: ' .
|
|
$studiengang_kz .
|
|
', studiensemester: ' .
|
|
$studiensemester_kurzbz .
|
|
', ausbildungssemester: ' .
|
|
($ausbildungssemester));
|
|
}
|
|
if (count($result) > 1)
|
|
return error('Multiple studienplaene found for stg: ' .
|
|
$studiengang_kz .
|
|
', studiensemester: ' .
|
|
$studiensemester_kurzbz .
|
|
', ausbildungssemester: ' .
|
|
$ausbildungssemester);
|
|
$studienplan = current($result);
|
|
|
|
return $this->_ci->StudienplanModel->getStudienplanLehrveranstaltungForPrestudent(
|
|
$studienplan->studienplan_id,
|
|
$ausbildungssemester,
|
|
$prestudent_id,
|
|
$note_stsem
|
|
);
|
|
}
|
|
|
|
/**
|
|
* 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'))) {
|
|
$result = $this->_ci->StudierendenantragModel->loadWithStatusWhere(['prestudent_id' => $prestudent_id, 'typ' => Studierendenantrag_model::TYP_ABMELDUNG, 'campus.get_status_studierendenantrag(studierendenantrag_id)' => Studierendenantragstatus_model::STATUS_APPROVED]);
|
|
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)
|
|
{
|
|
if ($antrag->status == Studierendenantragstatus_model::STATUS_CREATED || $antrag->status == Studierendenantragstatus_model::STATUS_CREATED_STGL)
|
|
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)
|
|
{
|
|
$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));
|
|
$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_UNTERBRECHUNG, 'campus.get_status_studierendenantrag(studierendenantrag_id)' => Studierendenantragstatus_model::STATUS_APPROVED]);
|
|
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)
|
|
{
|
|
if($antrag->status == Studierendenantragstatus_model::STATUS_CREATED || $antrag->status == Studierendenantragstatus_model::STATUS_CREATED_STGL)
|
|
return success(-2);
|
|
elseif($antrag->status == Studierendenantragstatus_model::STATUS_APPROVED && $antrag->datum > $datumStatus)
|
|
return success(-2);
|
|
}
|
|
if ($studiensemester_kurzbz && $antrag->typ == Studierendenantrag_model::TYP_UNTERBRECHUNG)
|
|
{
|
|
// NOTE(chris): check if this is an old or canceled one
|
|
if ($antrag->studiensemester_kurzbz == $studiensemester_kurzbz && $antrag->status != Studierendenantragstatus_model::STATUS_CANCELLED)
|
|
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 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, 'campus.get_status_studierendenantrag(studierendenantrag_id)' => Studierendenantragstatus_model::STATUS_APPROVED]);
|
|
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)
|
|
{
|
|
if($antrag->status == Studierendenantragstatus_model::STATUS_CREATED || $antrag->status == Studierendenantragstatus_model::STATUS_CREATED_STGL)
|
|
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('No Studentstatus found for: ' . $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('No Studentstatus found for: ' . $prestudent_id);
|
|
$resultDetails = current(getData($result));
|
|
|
|
$where = [
|
|
'prestudent_id' => $prestudent_id
|
|
];
|
|
if ($typ)
|
|
$where['typ'] = $typ;
|
|
$result = $this->_ci->StudierendenantragModel->loadWithStatusWhere($where);
|
|
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('No Antrag ' . trim(($typ ?: '') . ' ') . 'found for: ' . $prestudent_id);
|
|
|
|
$resultDetails->status = $resultAntrag->status;
|
|
$resultDetails->statustyp = $resultAntrag->statustyp;
|
|
$resultDetails->grund = $resultAntrag->grund;
|
|
$resultDetails->studierendenantrag_id = $resultAntrag->studierendenantrag_id;
|
|
$resultDetails->typ = $resultAntrag->typ;
|
|
|
|
return success($resultDetails);
|
|
}
|
|
|
|
public function getDetailsForAntrag($studierendenantrag_id)
|
|
{
|
|
$where = [
|
|
'studierendenantrag_id' => $studierendenantrag_id
|
|
];
|
|
|
|
$result = $this->_ci->StudierendenantragModel->loadWithStatusWhere($where);
|
|
if (isError($result))
|
|
return $result;
|
|
|
|
if (!hasData($result))
|
|
return error("No Antrag found with 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('No Studentstatus found for: ' . $resultAntrag->prestudent_id);
|
|
}
|
|
$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);
|
|
}
|
|
|
|
public function getSemesterForUnterbrechung($studiengang_kz, $studiensemester_kurzbz, $ausbildungssemester)
|
|
{
|
|
$this->_ci->load->model('organisation/Studienplan_model', 'StudienplanModel');
|
|
$this->_ci->load->model('organisation/Studiensemester_model', 'StudiensemesterModel');
|
|
|
|
$result = $this->_ci->StudienplanModel->getStudienplaeneBySemester($studiengang_kz, $studiensemester_kurzbz, $ausbildungssemester);
|
|
if (!hasData($result))
|
|
return [];
|
|
|
|
$studienplaene = getData($result);
|
|
$studienplan_ids = array_map(function ($studienplan) {
|
|
return $studienplan->studienplan_id;
|
|
}, $studienplaene);
|
|
|
|
$result = $this->_ci->StudiensemesterModel->getFollowingSemester($studienplan_ids, $studiensemester_kurzbz, $ausbildungssemester);
|
|
if (!hasData($result))
|
|
return [];
|
|
|
|
$stsems = getData($result);
|
|
|
|
$result = $this->_ci->StudiensemesterModel->loadWhere();
|
|
if (!hasData($result))
|
|
return [];
|
|
$result = getData($result);
|
|
usort($result, function($a, $b) {
|
|
return $a->start > $b->start ? 1 : -1;
|
|
});
|
|
foreach ($stsems as $stsem) {
|
|
$stsem->wiedereinstieg = array_filter($result, function ($sem) use ($stsem) {
|
|
return $sem->start > $stsem->ende;
|
|
});
|
|
}
|
|
|
|
return $stsems;
|
|
}
|
|
|
|
public function getAbmeldeBerechtigtForStg($studiengaenge)
|
|
{
|
|
$blacklist = $this->_ci->config->item('stgkz_blacklist_abmeldung');
|
|
$studiengaenge = array_diff($studiengaenge, $blacklist);
|
|
return $this->_ci->StudiengangModel->getAktivePrestudenten($studiengaenge, [
|
|
Studierendenantrag_model::TYP_ABMELDUNG
|
|
]);
|
|
}
|
|
|
|
public function getFailedExamForPrestudent($prestudent_id)
|
|
{
|
|
return $this->_ci->PruefungModel->loadWhereCommitteeExamFailedForPrestudent($prestudent_id);
|
|
}
|
|
|
|
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)
|
|
{
|
|
$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('No studiengang email found for: ' . $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('No studiengang found for: ' . $antrag_id);
|
|
|
|
$result = current($result);
|
|
$studiengang_kz = $result->studiengang_kz;
|
|
$semester = $result->ausbildungssemester;
|
|
|
|
$result = $this->_ci->StudiengangModel->load($studiengang_kz);
|
|
if (isError($result))
|
|
return $result;
|
|
$result = getData($result);
|
|
if (!$result)
|
|
return error('No studiengang found for: ' . $antrag_id);
|
|
|
|
$stg = current($result);
|
|
|
|
$result = $this->_ci->StudierendenantragModel->load($antrag_id);
|
|
if (isError($result))
|
|
return $result;
|
|
if (!hasData($result))
|
|
return error('No Antrag found for: ' . $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('No Person found for prestudent: ' . $prestudent_id);
|
|
$result = current(getData($result));
|
|
$student = trim($result->vorname . ' ' . $result->nachname);
|
|
|
|
$result = $this->_ci->PersonModel->getFullName($insertvon);
|
|
if (isError($result))
|
|
return $result;
|
|
$mitarbeiter = $insertvon;
|
|
if (hasData($result)) {
|
|
$mitarbeiter = getData($result);
|
|
}
|
|
|
|
|
|
// NOTE(chris): Sancho mail
|
|
if (!sendSanchoMail(
|
|
'Sancho_Mail_Antrag_W_Approve',
|
|
[
|
|
'antrag_id' => $antrag_id,
|
|
'stg' => $stg->bezeichnung,
|
|
'sem' => $semester,
|
|
'student' => $student,
|
|
'mitarbeiter' => $mitarbeiter
|
|
],
|
|
$email,
|
|
'Wiederholung von Stgleitung freigegeben'
|
|
))
|
|
return error('Email konnte nicht versendet werden an '. $email);
|
|
|
|
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)
|
|
{
|
|
return $this->isOwnAntrag($antrag_id);
|
|
}
|
|
|
|
/**
|
|
* @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
|
|
* @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
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function getLvsForPrestudent($prestudent_id, $studiensemester_kurzbz)
|
|
{
|
|
$result = $this->_ci->StudierendenantraglehrveranstaltungModel->getLvsForPrestudent($prestudent_id, $studiensemester_kurzbz);
|
|
return $result;
|
|
}
|
|
}
|