blackicedbear/FHC-Core
1
0
Fork 0
mirror of https://github.com/FH-Complete/FHC-Core.git synced 2026-07-22 01:12:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

Cleaned up commit from 'feature-27351/Digitalisierung_Formulare_Abmeldung_Unterbrechung_Wiederholung'

Browse Source
This commit is contained in:
cgfhtw
2023-07-04 10:34:14 +02:00
parent 5213ab44ff
commit 64ce3d1f6a
82 changed files with 12192 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files
application/controllers/components/Antrag/Abmeldung.php
+201
View File
@@ -0,0 +1,201 @@
<?php
if (! defined('BASEPATH')) exit('No direct script access allowed');
use \Studierendenantrag_model as Studierendenantrag_model;
/**
*
*/
class Abmeldung extends FHC_Controller
{
/**
* Calls the parent's constructor and loads the FilterCmptLib
*/
public function __construct()
{
parent::__construct();
// Libraries
$this->load->library('AuthLib');
$this->load->library('AntragLib');
// Load language phrases
$this->loadPhrases([
'studierendenantrag'
]);
}
//------------------------------------------------------------------------------------------------------------------
// Public methods
/**
* Retrieves data of the current studiengang for the current user
*/
public function getDetailsForNewAntrag($prestudent_id)
{
if (!$this->antraglib->isEntitledToCreateAntragFor($prestudent_id, true)) {
$this->output->set_status_header(403);
return $this->outputJsonError('Forbidden');
}
$result = $this->antraglib->getPrestudentAbmeldeBerechtigt($prestudent_id);
if (isError($result)) {
$this->output->set_status_header(500);
return $this->outputJsonError(getError($result));
}
$result = $result->retval;
if (!$result) {
$this->output->set_status_header(403);
return $this->outputJsonError($this->p->t('studierendenantrag', 'error_no_student'));
}
elseif ($result == -3)
{
$this->output->set_status_header(403);
return $this->outputJsonError($this->p->t('studierendenantrag', 'error_stg_blacklist'));
}
elseif ($result == -1)
{
$result = $this->antraglib->getDetailsForLastAntrag($prestudent_id, Studierendenantrag_model::TYP_ABMELDUNG);
if (isError($result)) {
return $this->outputJsonError(getError($result));
}
$data = getData($result);
$data->canCancel = (boolean)$this->antraglib->isEntitledToCancelAntrag($data->studierendenantrag_id);
return $this->outputJsonSuccess($data);
}
$result = $this->antraglib->getDetailsForNewAntrag($prestudent_id);
if (isError($result)) {
return $this->outputJsonError(getError($result));
}
$this->outputJsonSuccess(getData($result));
}
public function createAntrag()
{
$this->load->library('form_validation');
$_POST = json_decode($this->input->raw_input_stream, true);
$this->form_validation->set_rules('studiensemester', 'Studiensemester', 'required');
$this->form_validation->set_rules('prestudent_id', 'Prestudent ID', 'required');
$this->form_validation->set_rules('grund', 'Grund', 'required');
if ($this->form_validation->run() == false)
{
return $this->outputJsonError($this->form_validation->error_array());
}
$grund = $this->input->post('grund');
$studiensemester = $this->input->post('studiensemester');
$prestudent_id = $this->input->post('prestudent_id');
$result = $this->antraglib->getPrestudentAbmeldeBerechtigt($prestudent_id);
if (isError($result)) {
return $this->outputJsonError(['db' => getError($result)]);
}
$result = $result->retval;
if (!$result)
{
return $this->outputJsonError(['db' => $this->p->t('studierendenantrag', 'error_no_student')]);
}
elseif ($result == -3)
{
return $this->outputJsonError(['db' => $this->p->t('studierendenantrag', 'error_stg_blacklist')]);
}
elseif ($result < 0)
{
return $this->outputJsonError(['db' => $this->p->t('studierendenantrag', 'error_antrag_exists')]);
}
$result = $this->antraglib->createAbmeldung($prestudent_id, $studiensemester, getAuthUID(), $grund);
if (isError($result))
{
return $this->outputJsonError(['db' => getError($result)]);
}
$result = $this->antraglib->getDetailsForAntrag(getData($result));
if (!hasData($result))
return $this->outputJsonSuccess(true);
$data = getData($result);
$data->canCancel = (boolean)$this->antraglib->isEntitledToCancelAntrag($data->studierendenantrag_id);
$this->outputJsonSuccess($data);
}
public function cancelAntrag()
{
$this->load->library('form_validation');
$_POST = json_decode($this->input->raw_input_stream, true);
$this->form_validation->set_rules('antrag_id', 'Antrag ID', 'required');
if ($this->form_validation->run() == false)
{
return $this->outputJsonError($this->form_validation->error_array());
}
$antrag_id = $this->input->post('antrag_id');
if(!$this->antraglib->isEntitledToCancelAntrag($antrag_id))
{
$this->output->set_status_header(403);
return $this->outputJsonError('Forbidden');
}
$result = $this->antraglib->cancelAntrag($antrag_id, getAuthUID());
if(isError($result))
{
return $this->outputJsonError(['db' => getError($result)]);
}
$result = $this->antraglib->getDetailsForAntrag($antrag_id);
if (!hasData($result))
return $this->outputJsonSuccess($antrag_id);
$this->outputJsonSuccess(getData($result));
}
public function getStudiengaengeAssistenz()
{
$this->load->library('PermissionLib');
$studiengaenge = $this->permissionlib->getSTG_isEntitledFor('student/studierendenantrag');
$result = $this->antraglib->getAbmeldeBerechtigtForStg($studiengaenge);
if (isError($result)) {
return $this->outputJsonError(getError($result));
}
$result = getData($result);
if (!$result) {
return $this->outputJsonSuccess([]);
}
$sortedStudents = [];
foreach ($result as $item) {
if (!isset($sortedStudents[$item->studiengang_kz]))
$sortedStudents[$item->studiengang_kz] = [
'bezeichnung' => $item->bezeichnung,
'orgform' => $item->orgform,
'studenten' => []
];
$sortedStudents[$item->studiengang_kz]['studenten'][] = [
'semester' => $item->semester,
'prestudent_id' => $item->prestudent_id,
'name' => trim($item->vorname . ' ' . $item->nachname),
'vorname' => $item->vorname,
'nachname' => $item->nachname,
'studiensemester_kurzbz' => $item->studiensemester_kurzbz
];
}
$this->outputJsonSuccess($sortedStudents);
}
}
application/controllers/components/Antrag/Leitung.php
+358
View File
@@ -0,0 +1,358 @@
<?php
if (! defined('BASEPATH')) exit('No direct script access allowed');
/**
*
*/
class Leitung extends FHC_Controller
{
/**
* Calls the parent's constructor and loads the FilterCmptLib
*/
public function __construct()
{
parent::__construct();
// Libraries
$this->load->library('AuthLib');
$this->load->library('AntragLib');
// Load language phrases
$this->loadPhrases([
'studierendenantrag'
]);
}
//------------------------------------------------------------------------------------------------------------------
// Public methods
public function getAntraege($studiengang = null)
{
if($studiengang)
$studiengaenge = [$studiengang];
else {
$studiengaenge =$this->permissionlib->getSTG_isEntitledFor('student/antragfreigabe');
if(!is_array($studiengaenge))
$studiengaenge = [];
$stgsNeuanlage = $this->permissionlib->getSTG_isEntitledFor('student/studierendenantrag');
if(!is_array($stgsNeuanlage))
$stgsNeuanlage = [];
$studiengaenge = array_unique(array_merge($studiengaenge, $stgsNeuanlage));
}
$antraege = [];
if ($studiengaenge) {
$result = $this->StudierendenantragModel->loadForStudiengaenge($studiengaenge);
if (isError($result)) {
$this->output->set_status_header(500);
return $this->outputJson('Internal Server Error');
}
$antraege = getData($result);
}
$this->outputJson($antraege);
}
public function reopenAntrag()
{
$this->load->library('form_validation');
$_POST = json_decode($this->input->raw_input_stream, true);
$this->form_validation->set_rules(
'studierendenantrag_id',
'Studierenden Antrag',
'required|callback_isEntitledToReopenAntrag',
[
'isEntitledToReopenAntrag' => $this->p->t('studierendenantrag','error_no_right')
]
);
if ($this->form_validation->run() == false)
{
return $this->outputJsonError($this->form_validation->error_array());
}
$studierendenantrag_id = $this->input->post('studierendenantrag_id');
$result = $this->antraglib->reopenWiederholung($studierendenantrag_id, getAuthUID());
if (isError($result))
return $this->outputJsonError(['studierendenantrag_id' => getError($result)]);
$this->outputJsonSuccess($studierendenantrag_id);
}
public function objectAntrag()
{
$this->load->library('form_validation');
$_POST = json_decode($this->input->raw_input_stream, true);
$this->form_validation->set_rules(
'studierendenantrag_id',
'Studierenden Antrag',
'required|callback_isEntitledToObjectAntrag|callback_canBeObjected',
[
'isEntitledToObjectAntrag' => $this->p->t('studierendenantrag','error_no_right'),
'canBeObjected' => $this->p->t('studierendenantrag','error_no_objection')
]
);
if ($this->form_validation->run() == false)
{
return $this->outputJsonError($this->form_validation->error_array());
}
$studierendenantrag_id = $this->input->post('studierendenantrag_id');
$result = $this->antraglib->objectAbmeldung($studierendenantrag_id, getAuthUID());
if (isError($result))
return $this->outputJsonError(['studierendenantrag_id' => getError($result)]);
$this->outputJsonSuccess($studierendenantrag_id);
}
public function objectionDeny()
{
$this->load->library('form_validation');
$_POST = json_decode($this->input->raw_input_stream, true);
$this->form_validation->set_rules(
'studierendenantrag_id',
'Studierenden Antrag',
'required|callback_isEntitledToObjectAntrag|callback_isObjected',
[
'isEntitledToObjectAntrag' => $this->p->t('studierendenantrag','error_no_right'),
'isObjected' => $this->p->t('studierendenantrag','error_not_objected')
]
);
if ($this->form_validation->run() == false)
{
return $this->outputJsonError($this->form_validation->error_array());
}
$studierendenantrag_id = $this->input->post('studierendenantrag_id');
$result = $this->antraglib->approveAbmeldung([$studierendenantrag_id], getAuthUID());
if (isError($result))
return $this->outputJsonError(['studierendenantrag_id' => getError($result)]);
$this->outputJsonSuccess($studierendenantrag_id);
}
public function objectionApprove()
{
$this->load->library('form_validation');
$_POST = json_decode($this->input->raw_input_stream, true);
$this->form_validation->set_rules(
'studierendenantrag_id',
'Studierenden Antrag',
'required|callback_isEntitledToObjectAntrag|callback_isObjected',
[
'isEntitledToObjectAntrag' => $this->p->t('studierendenantrag','error_no_right'),
'isObjected' => $this->p->t('studierendenantrag','error_not_objected')
]
);
if ($this->form_validation->run() == false)
{
return $this->outputJsonError($this->form_validation->error_array());
}
$studierendenantrag_id = $this->input->post('studierendenantrag_id');
$result = $this->antraglib->cancelAntrag($studierendenantrag_id, getAuthUID());
if (isError($result))
return $this->outputJsonError(['studierendenantrag_id' => getError($result)]);
$this->outputJsonSuccess($studierendenantrag_id);
}
public function isEntitledToReopenAntrag($studierendenantrag_id)
{
return $this->antraglib->isEntitledToReopenAntrag($studierendenantrag_id);
}
public function isEntitledToObjectAntrag($studierendenantrag_id)
{
return $this->antraglib->isEntitledToObjectAntrag($studierendenantrag_id);
}
public function isEntitledToRejectAntrag($studierendenantrag_id)
{
return $this->antraglib->isEntitledToRejectAntrag($studierendenantrag_id);
}
public function canBeObjected($studierendenantrag_id)
{
return $this->antraglib->hasStatus($studierendenantrag_id, Studierendenantragstatus_model::STATUS_APPROVED_STGL);
}
public function isObjected($studierendenantrag_id)
{
return $this->antraglib->hasStatus($studierendenantrag_id, Studierendenantragstatus_model::STATUS_OBJECTED);
}
public function approveAbmeldung()
{
$this->load->library('form_validation');
$_POST = json_decode($this->input->raw_input_stream, true);
$this->form_validation->set_rules(
'studierendenantrag_id',
'Studierenden Antrag',
'required|callback_isEntitledToApproveAntrag',
[
'isEntitledToApproveAntrag' => $this->p->t('studierendenantrag','error_no_right')
]
);
if ($this->form_validation->run() == false)
{
return $this->outputJsonError($this->form_validation->error_array());
}
$studierendenantrag_id = $this->input->post('studierendenantrag_id');
$result = $this->antraglib->approveAbmeldung([$studierendenantrag_id], getAuthUID());
if (isError($result))
{
return $this->outputJsonError(['db' => getError($result)]);
}
return $this->outputJsonSuccess($studierendenantrag_id);
}
public function approveUnterbrechung()
{
$this->load->library('form_validation');
$_POST = json_decode($this->input->raw_input_stream, true);
$this->form_validation->set_rules(
'studierendenantrag_id',
'Studierenden Antrag',
'required|callback_isEntitledToApproveAntrag',
[
'isEntitledToApproveAntrag' => $this->p->t('studierendenantrag','error_no_right')
]
);
if ($this->form_validation->run() == false)
{
return $this->outputJsonError($this->form_validation->error_array());
}
$studierendenantrag_id = $this->input->post('studierendenantrag_id');
$result = $this->antraglib->approveUnterbrechung([$studierendenantrag_id], getAuthUID());
if (isError($result))
{
return $this->outputJsonError(['db' => getError($result)]);
}
return $this->outputJsonSuccess($studierendenantrag_id);
}
public function rejectUnterbrechung()
{
$this->load->library('form_validation');
$_POST = json_decode($this->input->raw_input_stream, true);
$this->form_validation->set_rules(
'studierendenantrag_id',
'Studierenden Antrag',
'required|callback_isEntitledToRejectAntrag',
[
'isEntitledToRejectAntrag' => $this->p->t('studierendenantrag','error_no_right')
]
);
$this->form_validation->set_rules('grund', 'Grund', 'required');
if ($this->form_validation->run() == false)
{
return $this->outputJsonError($this->form_validation->error_array());
}
$studierendenantrag_id = $this->input->post('studierendenantrag_id');
$grund = $this->input->post('grund');
$result = $this->antraglib->rejectUnterbrechung([$studierendenantrag_id], getAuthUID(), $grund);
if (isError($result))
{
return $this->outputJsonError(['db' => getError($result)]);
}
return $this->outputJsonSuccess($studierendenantrag_id);
}
public function approveWiederholung()
{
$this->load->library('form_validation');
$_POST = json_decode($this->input->raw_input_stream, true);
$this->form_validation->set_rules(
'studierendenantrag_id',
'Studierenden Antrag',
'required|callback_isEntitledToApproveAntrag',
[
'isEntitledToApproveAntrag' => $this->p->t('studierendenantrag','error_no_right')
]
);
if ($this->form_validation->run() == false)
{
return $this->outputJsonError($this->form_validation->error_array());
}
$studierendenantrag_id = $this->input->post('studierendenantrag_id');
$result = $this->antraglib->approveWiederholung($studierendenantrag_id, getAuthUID());
if (isError($result))
{
return $this->outputJsonError(['db' => getError($result)]);
}
return $this->outputJsonSuccess($studierendenantrag_id);
}
public function isEntitledToApproveAntrag($studierendenantrag_id)
{
return $this->antraglib->isEntitledToApproveAntrag($studierendenantrag_id);
}
public function getHistory($studierendenantrag_id)
{
if (!$this->antraglib->isEntitledToSeeHistoryForAntrag($studierendenantrag_id)) {
$this->output->set_status_header(403);
return $this->outputJson('Forbidden');
}
$result = $this->antraglib->getAntragHistory($studierendenantrag_id);
if (isError($result)) {
return $this->outputJsonError(getError($result));
}
$this->outputJsonSuccess(getData($result) ?: []);
}
}
application/controllers/components/Antrag/Unterbrechung.php
+230
View File
@@ -0,0 +1,230 @@
<?php
if (! defined('BASEPATH')) exit('No direct script access allowed');
use \Studierendenantrag_model as Studierendenantrag_model;
use \DateTime as DateTime;
/**
*
*/
class Unterbrechung extends FHC_Controller
{
/**
* Calls the parent's constructor and loads the FilterCmptLib
*/
public function __construct()
{
parent::__construct();
// Configs
$this->load->config('studierendenantrag');
// Libraries
$this->load->library('AuthLib');
$this->load->library('AntragLib');
// Load language phrases
$this->loadPhrases([
'studierendenantrag'
]);
}
//------------------------------------------------------------------------------------------------------------------
// Public methods
public function getDetailsForNewAntrag($prestudent_id)
{
if (!$this->antraglib->isEntitledToCreateAntragFor($prestudent_id, false)) {
$this->output->set_status_header(403);
return $this->outputJsonError('Forbidden');
}
$result = $this->antraglib->getPrestudentUnterbrechungsBerechtigt($prestudent_id);
if (isError($result)) {
$this->output->set_status_header(500);
return $this->outputJsonError(getError($result));
}
$result = $result->retval;
if (!$result) {
$this->output->set_status_header(403);
return $this->outputJsonError($this->p->t('studierendenantrag', 'error_no_student'));
}
elseif ($result == -1)
{
$result = $this->antraglib->getDetailsForLastAntrag($prestudent_id, Studierendenantrag_model::TYP_UNTERBRECHUNG);
if (isError($result)) {
return $this->outputJsonError(getError($result));
}
return $this->outputJsonSuccess(getData($result));
}
elseif ($result == -2)
{
$result = $this->antraglib->getDetailsForLastAntrag($prestudent_id);
if (isError($result)) {
return $this->outputJsonError(getError($result));
}
$result = getData($result);
$this->output->set_status_header(400);
return $this->outputJsonError($this->p->t('studierendenantrag', 'error_antrag_pending', ['typ' => $this->p->t('studierendenantrag','antrag_typ_' . $result->typ)]));
}
elseif ($result == -3)
{
$this->output->set_status_header(403);
return $this->outputJsonError($this->p->t('studierendenantrag', 'error_stg_blacklist'));
}
$result = $this->antraglib->getDetailsForNewAntrag($prestudent_id);
if (isError($result)) {
return $this->outputJsonError(getError($result));
}
$data = getData($result);
$data->studiensemester = $this->antraglib->getSemesterForUnterbrechung($data->studiengang_kz, $data->studiensemester_kurzbz, $data->semester);
$this->outputJsonSuccess($data);
}
public function getDetailsForAntrag($studierendenantrag_id)
{
if (!$this->antraglib->isEntitledToShowAntrag($studierendenantrag_id)) return show_404();
$result = $this->antraglib->getDetailsForAntrag($studierendenantrag_id);
if (isError($result)) {
return $this->outputJsonError(getError($result));
}
$data = getData($result);
if ($data->typ !== Studierendenantrag_model::TYP_UNTERBRECHUNG)
return show_404();
$this->outputJsonSuccess($data);
}
public function createAntrag()
{
$this->load->library('form_validation');
$this->form_validation->set_rules('studiensemester', 'Studiensemester', 'required');
$this->form_validation->set_rules('prestudent_id', 'Prestudent ID', 'required');
$this->form_validation->set_rules('grund', 'Grund', 'required');
$this->form_validation->set_rules(
'datum_wiedereinstieg',
'Datum Wiedereinstieg',
'required|callback_isValidDate|callback_isDateInFuture',
[
'isValidDate' => $this->p->t('ui', 'error_invalid_date'),
'isDateInFuture' => $this->p->t('ui', 'error_invalid_date')
]
);
if ($this->form_validation->run() == false)
{
return $this->outputJsonError($this->form_validation->error_array());
}
$grund = $this->input->post('grund');
$studiensemester = $this->input->post('studiensemester');
$prestudent_id = $this->input->post('prestudent_id');
$datum_wiedereinstieg = $this->input->post('datum_wiedereinstieg');
$dms_id = null;
$result = $this->antraglib->getPrestudentUnterbrechungsBerechtigt($prestudent_id);
if (isError($result)) {
return $this->outputJsonError(['db' => getError($result)]);
}
$result = $result->retval;
if (!$result)
{
return $this->outputJsonError(['db' => $this->p->t('studierendenantrag', 'error_no_student')]);
}
elseif ($result == -3)
{
return $this->outputJsonError(['db' => $this->p->t('studierendenantrag', 'error_stg_blacklist')]);
}
elseif ($result < 0)
{
return $this->outputJsonError(['db' => $this->p->t('studierendenantrag', 'error_antrag_exists')]);
}
if(isset($_FILES['attachment']) && (!isset($_FILES['attachment']['error']) || $_FILES['attachment']['error'] != UPLOAD_ERR_NO_FILE))
{
$this->load->library('DmsLib');
$dms = $this->config->item('unterbrechung_dms');
if (!count(array_filter($dms, function ($v) {
return $v !== null;
})))
$dms = ['kategorie_kurzbz' => 'Akte'];
$dms['version'] = 0;
$allowed_filetypes = $this->config->item('unterbrechung_dms_filetypes') ?: ['*'];
$result = $this->dmslib->upload($dms, 'attachment', $allowed_filetypes);
if(isError($result))
{
return $this->outputJsonError(['db' => getError($result)]);
}
$dms_id = getData($result)['dms_id'];
}
$result = $this->antraglib->createUnterbrechung($prestudent_id, $studiensemester, getAuthUID(), $grund, $datum_wiedereinstieg, $dms_id);
if(isError($result))
{
return $this->outputJsonError(['db' => getError($result)]);
}
$antragId = getData($result);
$result = $this->antraglib->getDetailsForAntrag($antragId);
if(!hasData($result))
return $this->outputJsonSuccess($antragId);
$this->outputJsonSuccess(getData($result));
}
public function cancelAntrag()
{
$this->load->library('form_validation');
$_POST = json_decode($this->input->raw_input_stream, true);
$this->form_validation->set_rules('antrag_id', 'Antrag ID', 'required');
if ($this->form_validation->run() == false)
{
return $this->outputJsonError($this->form_validation->error_array());
}
$antrag_id = $this->input->post('antrag_id');
$result = $this->antraglib->cancelAntrag($antrag_id, getAuthUID());
if (isError($result))
{
return $this->outputJsonError(['db' => getError($result)]);
}
$result = $this->antraglib->getDetailsForAntrag($antrag_id);
if (!hasData($result))
return $this->outputJsonSuccess($antrag_id);
$this->outputJsonSuccess(getData($result));
}
public function isValidDate($date)
{
try {
new DateTime($date);
} catch (Exception $e) {
return false;
}
return true;
}
public function isDateInFuture($date)
{
return new DateTime() < new DateTime($date);
}
}
application/controllers/components/Antrag/Wiederholung.php
+369
View File
@@ -0,0 +1,369 @@
<?php
if (! defined('BASEPATH')) exit('No direct script access allowed');
use \REST_Controller as REST_Controller;
/**
*
*/
class Wiederholung extends FHC_Controller
{
/**
* Calls the parent's constructor and loads the FilterCmptLib
*/
public function __construct()
{
parent::__construct();
// Configs
$this->load->config('studierendenantrag');
// Libraries
$this->load->library('AuthLib');
$this->load->library('PermissionLib');
$this->load->library('AntragLib');
$requiredPermissions = [
'saveLvs' => ['student/studierendenantrag:w'],
'getLvsAsRdf' => ['student/studierendenantrag:r', 'student/noten:r'],
'moveLvsToZeugnis' => ['student/studierendenantrag:w', 'student/noten:w']
];
if (isset($requiredPermissions[$this->router->method])) {
if (!$this->permissionlib->isEntitled($requiredPermissions, $this->router->method)) {
$this->output->set_status_header(REST_Controller::HTTP_FORBIDDEN);
$this->outputJson('Forbidden');
exit;
}
}
// Load language phrases
$this->loadPhrases([
'studierendenantrag'
]);
}
//------------------------------------------------------------------------------------------------------------------
// Public methods
/**
* Retrieves data of the current studiengang for the current user
*/
public function getDetailsForNewAntrag($prestudent_id)
{
if (!$this->antraglib->isEntitledToCreateAntragFor($prestudent_id, false)) {
$this->output->set_status_header(REST_Controller::HTTP_FORBIDDEN);
return $this->outputJsonError('Forbidden');
}
$result = $this->antraglib->getPrestudentWiederholungsBerechtigt($prestudent_id);
if (isError($result)) {
$this->output->set_status_header(REST_Controller::HTTP_INTERNAL_SERVER_ERROR);
return $this->outputJsonError(getError($result));
}
$result = $result->retval;
if (!$result) {
// TODO(chris): ERROR Message
$this->output->set_status_header(REST_Controller::HTTP_FORBIDDEN);
return $this->outputJsonError($this->p->t('studierendenantrag','error_no_student_no_failed_exam'));
}
elseif ($result == -1)
{
$result = $this->antraglib->getDetailsForLastAntrag($prestudent_id, Studierendenantrag_model::TYP_WIEDERHOLUNG);
if (isError($result)) {
return $this->outputJsonError(getError($result));
}
$data = getData($result);
$result = $this->antraglib->getFailedExamForPrestudent($prestudent_id);
// NOTE(chris): error handling for this function should already happenden in antraglib->getPrestudentWiederholungsBerechtigt()
$pruefungsdata = current(getData($result));
$data->studiensemester_kurzbz = $pruefungsdata->studiensemester_kurzbz;
$data->lvbezeichnung = $pruefungsdata->lvbezeichnung;
$data->pruefungsdatum = $pruefungsdata->datum;
return $this->outputJsonSuccess($data);
}
elseif ($result == -2)
{
$result = $this->antraglib->getDetailsForLastAntrag($prestudent_id);
if (isError($result)) {
return $this->outputJsonError(getError($result));
}
$result = getData($result);
$this->output->set_status_header(REST_Controller::HTTP_BAD_REQUEST);
return $this->outputJsonError($this->p->t('studierendenantrag', 'error_antrag_pending', ['typ' => $this->p->t('studierendenantrag','antrag_typ_' . $result->typ)]));
}
elseif ($result == -3)
{
$this->output->set_status_header(REST_Controller::HTTP_BAD_REQUEST);
return $this->outputJsonError($this->p->t('studierendenantrag', 'error_stg_blacklist'));
}
$result = $this->antraglib->getDetailsForNewAntrag($prestudent_id);
if (isError($result)) {
return $this->outputJsonError(getError($result));
}
$data = getData($result);
$result = $this->antraglib->getFailedExamForPrestudent($prestudent_id);
// NOTE(chris): error handling for this function should already happenden in antraglib->getPrestudentWiederholungsBerechtigt()
$pruefungsdata = current(getData($result));
$data->studiensemester_kurzbz = $pruefungsdata->studiensemester_kurzbz;
$data->lvbezeichnung = $pruefungsdata->lvbezeichnung;
$data->pruefungsdatum = $pruefungsdata->datum;
$this->outputJsonSuccess($data);
}
public function createAntrag()
{
$this->createAntragWithStatus(true);
}
public function cancelAntrag()
{
$this->createAntragWithStatus(false);
}
protected function createAntragWithStatus($repeat)
{
$this->load->library('form_validation');
$_POST = json_decode($this->input->raw_input_stream, true);
$this->form_validation->set_rules('prestudent_id', 'Prestudent ID', 'required');
$this->form_validation->set_rules('studiensemester', 'Studiensemester', 'required');
if ($this->form_validation->run() == false)
{
return $this->outputJsonError($this->form_validation->error_array());
}
$prestudent_id = $this->input->post('prestudent_id');
$studiensemester = $this->input->post('studiensemester');
$result = $this->antraglib->getPrestudentWiederholungsBerechtigt($prestudent_id);
if (isError($result)) {
return $this->outputJsonError(['db' => getError($result)]);
}
$result = $result->retval;
if (!$result)
{
// TODO(chris): ERROR Message
return $this->outputJsonError(['db' => $this->p->t('studierendenantrag', 'error_no_student')]);
}
elseif ($result == -2)
{
return $this->outputJsonError(['db' => $this->p->t('studierendenantrag', 'error_antrag_exists')]);
}
elseif ($result == -3)
{
return $this->outputJsonError(['db' => $this->p->t('studierendenantrag', 'error_stg_blacklist')]);
}
$result = $this->antraglib->createWiederholung($prestudent_id, $studiensemester, getAuthUID(), $repeat);
if(isError($result))
{
return $this->outputJsonError(['db' => getError($result)]);
}
$antragId = getData($result);
$result = $this->antraglib->getDetailsForAntrag($antragId);
if(!hasData($result))
return $this->outputJsonSuccess(true);
$data = getData($result);
$result = $this->antraglib->getFailedExamForPrestudent($prestudent_id);
// NOTE(chris): error handling for this function should already happenden in antraglib->getPrestudentWiederholungsBerechtigt()
$pruefungsdata = current(getData($result));
$data->studiensemester_kurzbz = $pruefungsdata->studiensemester_kurzbz;
$data->lvbezeichnung = $pruefungsdata->lvbezeichnung;
$data->pruefungsdatum = $pruefungsdata->datum;
$this->outputJsonSuccess($data);
}
public function getLvs($antrag_id)
{
$result = $this->antraglib->getLvsForAntrag($antrag_id);
if (isError($result)) {
$error = getError($result);
if ($error == 'Forbidden')
$this->output->set_status_header(REST_Controller::HTTP_FORBIDDEN);
return $this->outputJsonError(getError($result));
}
$lvs = getData($result);
$this->outputJsonSuccess($lvs);
}
public function saveLvs()
{
$result = $this->getPostJSON();
$antragsLvs = array_merge($result->forbiddenLvs, $result->mandatoryLvs);
$insert = array_map(function ($lv) {
return [
'studierendenantrag_id' => $lv->studierendenantrag_id,
'lehrveranstaltung_id' => $lv->lehrveranstaltung_id,
'note' => $lv->zugelassen ? ($lv->zugelassen == 1 ? 0 : $this->config->item('wiederholung_note_angerechnet')) : $this->config->item('wiederholung_note_nicht_zugelassen'),
'anmerkung' => $lv->anmerkung,
'insertvon' => getAuthUID(),
'studiensemester_kurzbz' => $lv->studiensemester_kurzbz
];
}, $antragsLvs);
$antrag_ids = array_unique(array_map(function ($lv) {
return $lv['studierendenantrag_id'];
}, $insert));
foreach ($antrag_ids as $antrag_id) {
$result = $this->StudierendenantragModel->loadIdAndStatusWhere([
'studierendenantrag_id' => $antrag_id
]);
if (isError($result))
return $this->outputJsonError(getError($result));
if (!hasData($result))
return $this->outputJsonError($this->p->t('studierendenantrag', 'error_no_antrag_found', ['id' => $antrag_id]));
$antrag = current(getData($result));
if ($antrag->status != Studierendenantragstatus_model::STATUS_CREATED && $antrag->status != Studierendenantragstatus_model::STATUS_LVSASSIGNED)
return $this->outputJsonError($this->p->t('studierendenantrag', 'error_antrag_locked'));
}
if(!$antragsLvs)
return $this->outputJsonError($this->p->t('studierendenantrag', 'error_no_lv'));
$result = $this->antraglib->saveLvs($insert);
if (isError($result))
return $this->outputJsonError(getError($result));
$this->outputJsonSuccess(getData($result));
}
public function getLvsAsRdf($prestudent_id)
{
// header für no cache
$this->output->set_header("Cache-Control: no-cache");
$this->output->set_header("Cache-Control: post-check=0, pre-check=0", false);
$this->output->set_header("Expires: Mon, 26 Jul 1997 05:00:00 GMT");
$this->output->set_header("Pragma: no-cache");
$this->output->set_header("Content-type: application/xhtml+xml");
$this->load->library('VariableLib', ['uid' => getAuthUID()]);
$sem_akt = $this->variablelib->getVar('semester_aktuell');
$result = $this->antraglib->getLvsForPrestudent($prestudent_id, $sem_akt);
if (isError($result)) {
return $this->outputJsonError(getError($result));
}
$lvs = getData($result) ?: [];
$rdf_url = 'http://www.technikum-wien.at/antragnote';
$this->load->view('lehre/Antrag/Wiederholung/getLvs.rdf.php', [
'url' => $rdf_url,
'lvs' => $lvs
]);
}
public function moveLvsToZeugnis()
{
$anzahl = $this->input->post('anzahl');
$student_uid = $this->input->post('student_uid');
$this->load->model('education/Studierendenantraglehrveranstaltung_model', 'StudierendenantraglehrveranstaltungModel');
$this->load->model('education/Zeugnisnote_model', 'ZeugnisnoteModel');
$errormsg = array();
for($i=0; $i<$anzahl; $i++)
{
$id = $this->input->post('studierendenantrag_lehrveranstaltung_id_' . $i);
$result =$this->StudierendenantraglehrveranstaltungModel->load($id);
if(isError($result))
{
$errormsg[] = getError($result);
}
elseif(!hasData($result))
{
$errormsg[] = $this->p->t('studierendenantrag', 'error_no_lv_in_application');
}
else
{
$antragLv = getData($result)[0];
$result= $this->ZeugnisnoteModel->load([
'lehrveranstaltung_id'=> $antragLv->lehrveranstaltung_id,
'student_uid'=> $student_uid,
'studiensemester_kurzbz' => $antragLv->studiensemester_kurzbz
]);
if(isError($result))
{
$errormsg[] = getError($result);
}
else
{
if (hasData($result))
{
$result = $this->ZeugnisnoteModel->update(
[
'lehrveranstaltung_id'=> $antragLv->lehrveranstaltung_id,
'student_uid'=> $student_uid,
'studiensemester_kurzbz' => $antragLv->studiensemester_kurzbz
],
[
'note'=> $antragLv->note,
'uebernahmedatum' => date('c'),
'benotungsdatum' => $antragLv->insertamum,
'updateamum' => date('c'),
'bemerkung'=>$antragLv->anmerkung,
'updatevon'=>getAuthUID()
]
);
}
else
{
$result = $this->ZeugnisnoteModel->insert([
'lehrveranstaltung_id'=> $antragLv->lehrveranstaltung_id,
'student_uid'=> $student_uid,
'studiensemester_kurzbz' => $antragLv->studiensemester_kurzbz,
'note'=> $antragLv->note,
'uebernahmedatum' => date('c'),
'benotungsdatum' => $antragLv->insertamum,
'insertamum' => date('c'),
'bemerkung'=>$antragLv->anmerkung,
'insertvon'=>getAuthUID()
]);
}
if(isError($result))
{
$errormsg[] = getError($result);
}
}
}
}
if($errormsg)
$return = false;
else
$return = true;
$this->load->view('lehre/Antrag/Wiederholung/moveLvs.rdf.php', [
'return' => $return,
'errormsg' => $errormsg
]);
}
}
application/controllers/components/Phrasen.php
+23
View File
@@ -0,0 +1,23 @@
<?php
if (! defined('BASEPATH')) exit('No direct script access allowed');
/**
*
*/
class Phrasen extends FHC_Controller
{
//------------------------------------------------------------------------------------------------------------------
// Public methods
/**
* @param string $module
*/
public function loadModule($module)
{
$this->load->library('PhrasesLib', [$module], 'pj');
$this->outputJsonSuccess(json_decode($this->pj->getJSON()));
}
}
application/controllers/jobs/AntragJob.php
+406
View File
@@ -0,0 +1,406 @@
<?php
if (!defined("BASEPATH")) exit("No direct script access allowed");
use \DateTime as DateTime;
// TODO(chris): Achtung not working
class AntragJob extends JOB_Controller
{
/**
* API constructor
*/
public function __construct()
{
parent::__construct();
// Configs
$this->load->config('studierendenantrag');
// Loads SanchoHelper
$this->load->helper('hlp_sancho_helper');
//Load Model
$this->load->model('education/Studierendenantrag_model', 'StudierendenantragModel');
$this->load->model('education/Studierendenantragstatus_model', 'StudierendenantragstatusModel');
$this->load->model('education/Pruefung_model', 'PruefungModel');
$this->load->model('person/Kontakt_model', 'KontaktModel');
}
/**
* Send reminder to Assistant for Wiedereinstieg Unterbrecher
*
*/
public function sendReminderWiedereinstieg()
{
$now = new DateTime();
$modifier = $this->config->item('unterbrechung_job_remind_wiedereinstieg_date_modifier');
if (!$modifier)
return $this->logError('Konnte Job nicht starten: Config "unterbrechung_job_remind_wiedereinstieg_date_modifiers" nicht gesetzt');
$end = new DateTime();
$end->modify($modifier);
$this->logInfo(sprintf(
'Start Job sendReminderWiedereinstieg (Wiedereinstieg zwischen %s - %s)',
$now->format('Y-m-d'),
$end->format('Y-m-d')
));
$result = $this->StudierendenantragModel->getAntraegeWhereWiedereinstiegBetween($now, $end);
if(isError($result))
{
$this->logError(getError($result));
$this->logInfo('Ende Job sendReminderWiedereinstieg');
return;
}
$antraege = getData($result) ?: [];
$count = 0;
foreach ($antraege as $antrag)
{
$datum = new DateTime($antrag->datum_wiedereinstieg);
$data = array(
'prestudent' => $antrag->prestudent_id,
'name' => trim($antrag->vorname . ' '. $antrag->nachname),
'datum_wiedereinstieg' => $datum->format('d.m.Y')
);
if(sendSanchoMail('Sancho_Mail_Antrag_U_Reminder', $data, $antrag->email, 'Reminder: Unterbrechung Wiedereinstieg'))
{
$count++;
$this->StudierendenantragstatusModel->insert([
'studierendenantrag_id' => $antrag->studierendenantrag_id,
'studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_REMINDERSENT,
'insertvon' => 'AntragJob'
]);
}
}
$this->logInfo($count . ' Reminder gesendet - Ende Job sendReminderWiedereinstieg');
}
/**
* Set Wiederholer after deadline to Abbrecher
*
*/
public function handleWiederholerDeadline()
{
$this->logInfo('Start Job handleWiederholerDeadline');
$this->load->library('PrestudentLib');
$insertvon = $this->config->item('antrag_job_systemuser');
if (!$insertvon) {
$this->logError('Config "antrag_job_systemuser" nicht gesetzt');
$this->logInfo('Ende Job handleWiederholerDeadline');
return;
}
$modifier_deadline = $this->config->item('wiederholung_job_deadline_date_modifier');
if (!$modifier_deadline) {
$this->logError('Config "wiederholung_job_deadline_date_modifier" nicht gesetzt');
$this->logInfo('Ende Job handleWiederholerDeadline');
return;
}
$dateDeadline = new DateTime();
$dateDeadline->sub(DateInterval::createFromDateString($modifier_deadline));
$result = $this->PruefungModel->getAllPrestudentsWhereCommitteeExamFailed(
[
null,
Studierendenantragstatus_model::STATUS_REQUESTSENT_1,
Studierendenantragstatus_model::STATUS_REQUESTSENT_2
],
$dateDeadline,
null
);
if(isError($result))
{
$this->logError(getError($result));
}
else
{
$prestudents = getData($result) ?: [];
$count = 0;
$prestudents = $this->prestudentsGetUnique($prestudents);
foreach ($prestudents as $prestudent)
{
// TODO(chris): DEBUG REMOVE!
if ($prestudent->studiensemester_kurzbz == 'WS2021')
var_dump([$prestudent->prestudent_id, $prestudent->studiensemester_kurzbz, $prestudent->lvbezeichnung]);
$result = success();
// TODO(chris): find out how to filter old/wrong datasets!!!
#$result = $this->prestudentlib->setAbbrecher($prestudent->prestudent_id, $prestudent->studiensemester_kurzbz, $insertvon);
if (isError($result))
$this->logError(getError($result));
else
$count++;
}
$this->logInfo($count . " Students set to Abbrecher");
}
$this->logInfo('Ende Job handleWiederholerDeadline');
}
/**
* Set Abmeldungen after deadline to Abbrecher
*
*/
public function handleAbmeldungenStglDeadline()
{
$this->logInfo('Start Job handleAbmeldungenStglDeadline');
$this->load->library('AntragLib');
$insertvon = $this->config->item('antrag_job_systemuser');
if (!$insertvon) {
$this->logError('Config "antrag_job_systemuser" nicht gesetzt');
$this->logInfo('Ende Job handleAbmeldungenStglDeadline');
return;
}
$modifier_deadline = $this->config->item('abmeldung_job_deadline_date_modifier');
if (!$modifier_deadline) {
$this->logError('Config "abmeldung_job_deadline_date_modifier" nicht gesetzt');
$this->logInfo('Ende Job handleAbmeldungenStglDeadline');
return;
}
$dateDeadline = new DateTime();
$dateDeadline->sub(DateInterval::createFromDateString($modifier_deadline));
$result = $this->StudierendenantragModel->getWithLastStatusWhere(
[
'studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_APPROVED_STGL,
's.insertamum <=' => $dateDeadline->format('c')
]
);
if(isError($result))
{
$this->logError(getError($result));
}
else
{
$antraege = getData($result) ?: [];
$count = 0;
foreach ($antraege as $antrag)
{
$result = $this->antraglib->approveAbmeldung([$antrag->studierendenantrag_id], $insertvon);
if (isError($result))
$this->logError(getError($result));
else
$count++;
}
$this->logInfo($count . " Students set to Abbrecher");
}
$this->logInfo('Ende Job handleAbmeldungenStglDeadline');
}
/**
* Send Request to Student do Decide between Wiederholung and Verzicht
*
*/
public function sendAufforderungWiederholer()
{
$this->logInfo('Start Job sendAufforderungWiederholer');
$modifier_request_1 = $this->config->item('wiederholung_job_request_1_date_modifier');
$modifier_request_2 = $this->config->item('wiederholung_job_request_2_date_modifier');
$modifier_deadline = $this->config->item('wiederholung_job_deadline_date_modifier');
if ($modifier_deadline)
{
$dateDeadline = new DateTime();
$dateDeadline->sub(DateInterval::createFromDateString($modifier_deadline));
}
else
$dateDeadline = null;
//first request
if ($modifier_request_1)
$this->sendReminder(
'Request1',
null,
Studierendenantragstatus_model::STATUS_REQUESTSENT_1,
$dateDeadline,
$modifier_request_1,
$modifier_deadline,
'Aufforderung: Bekanntgabe Wiederholung'
);
else
$this->logError('Config "wiederholung_job_request_1_date_modifier" nicht gesetzt');
//second request
if ($modifier_request_2)
$this->sendReminder(
'Request2',
Studierendenantragstatus_model::STATUS_REQUESTSENT_1,
Studierendenantragstatus_model::STATUS_REQUESTSENT_2,
$dateDeadline,
$modifier_request_2,
$modifier_deadline,
'Reminder Aufforderung: Bekanntgabe Wiederholung'
);
else
$this->logError('Config "wiederholung_job_request_2_date_modifier" nicht gesetzt');
$this->logInfo('Ende Job sendAufforderungWiederholer');
}
protected function prestudentsGetUnique($prestudents) {
$result = [];
foreach ($prestudents as $prestudent) {
if (!isset($result[$prestudent->prestudent_id]))
$result[$prestudent->prestudent_id] = $prestudent;
else {
if ($result[$prestudent->prestudent_id]->datum > $prestudent->datum)
$result[$prestudent->prestudent_id] = $prestudent;
}
}
return $result;
}
protected function sendReminder($name, $status_from, $status_to, $deadline, $date_modifier, $modifier_deadline, $subject)
{
$this->logInfo('Start Job sendAufforderungWiederholer ' . $name);
$dateStichtag = new DateTime();
$dateStichtag->sub(DateInterval::createFromDateString($date_modifier));
$result = $this->PruefungModel->getAllPrestudentsWhereCommitteeExamFailed($status_from, $dateStichtag, $deadline);
if(isError($result))
{
$this->logError(getError($result));
}
else
{
$prestudents = getData($result) ?: [];
$count = 0;
$prestudents = $this->prestudentsGetUnique($prestudents);
foreach ($prestudents as $prestudent)
{
$stg_kz = $prestudent->studiengang_kz;
if (in_array($stg_kz, $this->config->item('stgkz_blacklist_wiederholung')))
continue;
$url = site_url('lehre/Studierendenantrag/wiederholung/' . $prestudent->prestudent_id);
$email = $this->KontaktModel->getZustellKontakt($prestudent->person_id, ['email']);
if (isError($email)) {
$this->logError(getError($email));
} else {
$email = getData($email);
if (!$email) {
$this->logError('No email contact found for person_id: ' . $prestudent->person_id);
}
else
{
$email = current($email)->kontakt;
$fristende = new DateTime($prestudent->datum);
$fristende->add(DateInterval::createFromDateString($modifier_deadline));
$dataMail = array(
'name'=> trim($prestudent->vorname . ' '. $prestudent->nachname),
'pers_kz'=> $prestudent->matrikelnr,
'studiengang' => $prestudent->bezeichnung,
'lvbezeichnung' => $prestudent->lvbezeichnung,
'datum_kp' => $prestudent->datum,
'studiensemester'=> $prestudent->studiensemester_kurzbz,
'orgform'=> $prestudent->orgform,
'url' => $url,
'fristablauf' => $fristende->format('d.m.Y')
);
if(sendSanchoMail('Sancho_Mail_Antrag_W_' . $name, $dataMail, $email, $subject))
{
$antrag_id = null;
$result = $this->StudierendenantragModel->loadWhere([
'prestudent_id' => $prestudent->prestudent_id,
'typ' => Studierendenantrag_model::TYP_WIEDERHOLUNG
]);
if (isError($result))
$this->logError(getError($result));
elseif (hasData($result))
$antrag_id = current(getData($result) ?: []) -> studierendenantrag_id;
if ($antrag_id == null)
{
$result = $this->StudierendenantragModel->insert([
'prestudent_id' => $prestudent->prestudent_id,
'studiensemester_kurzbz'=> $prestudent->studiensemester_kurzbz,
'datum' => date('c'),
'typ' => Studierendenantrag_model::TYP_WIEDERHOLUNG,
'insertvon' => 'AntragJob'
]);
if (isError($result))
$this->logError(getError($result));
else
$antrag_id = getData($result);
}
if ($antrag_id)
{
$result = $this->StudierendenantragstatusModel->insert([
'studierendenantrag_id' => $antrag_id,
'studierendenantrag_statustyp_kurzbz' => $status_to,
'insertvon' => 'AntragJob'
]);
if (isError($result))
$this->logError(getError($result));
}
$count++;
}
}
}
}
$this->logInfo($count . " Mails '" . $subject . "' sent");
}
$this->logInfo('Ende Job sendAufforderungWiederholer ' . $name);
}
// TODO(chris): REMOVE DEBUG!
/**
* Writes a cronjob info log
*/
protected function logInfo($response, $parameters = null)
{
echo $response . "\n";
}
/**
* Writes a cronjob debug log
*/
protected function logDebug($response, $parameters = null)
{
echo $response . "\n";
}
/**
* Writes a cronjob warning log
*/
protected function logWarning($response, $parameters = null)
{
echo $response . "\n";
}
/**
* Writes a cronjob error log
*/
protected function logError($response, $parameters = null)
{
echo $response . "\n";
}
}
application/controllers/lehre/Antrag/Attachment.php
+82
View File
@@ -0,0 +1,82 @@
<?php
if (! defined('BASEPATH')) exit('No direct script access allowed');
use \REST_Controller as REST_Controller;
/**
*/
class Attachment extends FHC_Controller
{
/**
* Constructor
*/
public function __construct()
{
parent::__construct();
$this->load->model('education/Studierendenantrag_model', 'StudierendenantragModel');
$this->load->library('DmsLib');
$this->load->library('AuthLib');
$this->load->library('PermissionLib');
}
// -----------------------------------------------------------------------------------------------------------------
// Public methods
/**
* @param integer $dms_id
*
* @return void
*/
public function show($dms_id)
{
$result = $this->StudierendenantragModel->loadWhere(['dms_id' => $dms_id]);
if (!getData($result))
return show_404();
if (!$this->permissionlib->isBerechtigt('student/antragfreigabe'))
{
$isSamePerson = false;
$antraege = getData($result);
$this->load->model('crm/Prestudent_model', 'PrestudentModel');
foreach ($antraege as $antrag)
{
$prestudent = $this->PrestudentModel->load($antrag->prestudent_id);
if(hasData($prestudent))
{
if(current(getData($prestudent))->person_id == getAuthPersonId())
{
$isSamePerson = true;
break;
}
}
}
if ($isSamePerson == false)
{
$this->output->set_status_header(REST_Controller::HTTP_FORBIDDEN); // set the HTTP header as unauthorized
$this->load->library('EPrintfLib'); // loads the EPrintfLib to format the output
// Prints the main error message
$this->eprintflib->printError('You are not allowed to access to this content');
// Prints the called controller name
$this->eprintflib->printInfo('Controller name: '.$this->router->class);
// Prints the called controller method name
$this->eprintflib->printInfo('Method name: '.$this->router->method);
// Prints the required permissions needed to access to this method
$this->eprintflib->printInfo('Required permissions: student/antragfreigabe');
return show_error('You are not entitled to read this document');
}
}
$result = $this->dmslib->download($dms_id);
if (isError($result))
return show_error(getError($result));
$this->outputFile(getData($result));
}
}
application/controllers/lehre/Antrag/Wiederholung.php
+49
View File
@@ -0,0 +1,49 @@
<?php
if (! defined('BASEPATH')) exit('No direct script access allowed');
use \DateTime as DateTime;
use \Studierendenantrag_model as Studierendenantrag_model;
use \REST_Controller as REST_Controller;
/**
*/
class Wiederholung extends Auth_Controller
{
/**
* Constructor
*/
public function __construct()
{
parent::__construct([
'assistenz'=> 'student/studierendenantrag:w'
]);
$this->load->library('AntragLib');
// Load language phrases
$this->loadPhrases([
'studierendenantrag'
]);
}
// -----------------------------------------------------------------------------------------------------------------
// Public methods
public function assistenz($antrag_id, $frame = false)
{
$result = $this->antraglib->getDetailsForAntrag($antrag_id);
if (isError($result))
return show_error(getError($result));
if (!hasData($result))
return show_404();
$this->load->view('lehre/Antrag/Wiederholung/Student', [
'antrag_id' => $antrag_id,
'antrag' => getData($result),
'frame' => $frame
]);
}
}
application/controllers/lehre/Studierendenantrag.php
+208
View File
@@ -0,0 +1,208 @@
<?php
if (! defined('BASEPATH')) exit('No direct script access allowed');
use \stdClass as stdClass;
/**
*/
class Studierendenantrag extends FHC_Controller
{
/**
* Constructor
*/
public function __construct()
{
parent::__construct();
// Load Libraries
$this->load->library('AuthLib');
$this->load->library('AntragLib');
// Load Models
$this->load->model('education/Studierendenantrag_model', 'StudierendenantragModel');
// Load language phrases
$this->loadPhrases([
'studierendenantrag'
]);
if (strtolower($this->router->method) === 'leitung')
$this->_isAllowed([
'leitung' => ['student/studierendenantrag:r', 'student/antragfreigabe:r']
]);
}
// -----------------------------------------------------------------------------------------------------------------
// Public methods
public function index()
{
$dataAntrag = $this->StudierendenantragModel->loadForPerson(getAuthPersonId());
if (isError($dataAntrag))
return show_error(getError($dataAntrag));
$dataAntrag = (getData($dataAntrag) ? : []);
$prestudentenArr = array();
foreach ($dataAntrag as $antrag)
{
if (!isset($prestudentenArr[$antrag->prestudent_id]))
{
$prestudentenArr[$antrag->prestudent_id] = array(
'allowedNewTypes' => array(),
'antraege'=> array(),
'bezeichnungStg' => $antrag->bezeichnung,
'bezeichnungOrgform' => $antrag->orgform
);
$result = $this->antraglib->getPrestudentAbmeldeBerechtigt($antrag->prestudent_id);
if (getData($result) == 1)
$prestudentenArr[$antrag->prestudent_id]['allowedNewTypes'][] = 'Abmeldung';
$result = $this->antraglib->getPrestudentUnterbrechungsBerechtigt($antrag->prestudent_id);
if (getData($result) == 1)
$prestudentenArr[$antrag->prestudent_id]['allowedNewTypes'][] = 'Unterbrechung';
$result = $this->antraglib->getPrestudentWiederholungsBerechtigt($antrag->prestudent_id);
if (getData($result) == 1)
$prestudentenArr[$antrag->prestudent_id]['allowedNewTypes'][] = 'Wiederholung';
}
if ($antrag->studierendenantrag_id == null)
continue;
$prestudentenArr[$antrag->prestudent_id]['antraege'][] = $antrag;
}
$this->load->view('lehre/Antrag/Student/List', [
'antraege' => $prestudentenArr
]);
}
public function leitung()
{
$studiengaenge = $this->permissionlib->getSTG_isEntitledFor('student/antragfreigabe');
$stgsNeuanlage = $this->permissionlib->getSTG_isEntitledFor('student/studierendenantrag');
$stgL = [];
if ($studiengaenge) {
$result = $this->StudierendenantragModel->loadForStudiengaenge($studiengaenge);
if (isError($result))
return show_error(getError($result));
$antraege = getData($result) ?: [];
foreach ($antraege as $antrag) {
if (!isset($stgL[$antrag->studiengang_kz])) {
$stgL[$antrag->studiengang_kz] = new stdClass();
$stgL[$antrag->studiengang_kz]->bezeichnung = $antrag->bezeichnung;
$stgL[$antrag->studiengang_kz]->orgform = $antrag->orgform;
$stgL[$antrag->studiengang_kz]->studiengang_kz = $antrag->studiengang_kz;
}
}
}
$stgA = [];
if ($stgsNeuanlage) {
$result = $this->StudierendenantragModel->loadForStudiengaenge($stgsNeuanlage);
if (isError($result))
return show_error(getError($result));
$antraege = getData($result) ?: [];
foreach ($antraege as $antrag) {
if (!isset($stgA[$antrag->studiengang_kz])) {
$stgA[$antrag->studiengang_kz] = new stdClass();
$stgA[$antrag->studiengang_kz]->bezeichnung = $antrag->bezeichnung;
$stgA[$antrag->studiengang_kz]->orgform = $antrag->orgform;
$stgA[$antrag->studiengang_kz]->studiengang_kz = $antrag->studiengang_kz;
}
}
}
$this->load->view('lehre/Antrag/Leitung/List', [
'stgA' => $stgA,
'stgL' => $stgL
]);
}
public function abmeldung($prestudent_id, $studierendenantrag_id = null)
{
$this->load->view('lehre/Antrag/Create', [
'prestudent_id' => $prestudent_id,
'studierendenantrag_id' => $studierendenantrag_id,
'antrag_type' => 'Abmeldung'
]);
}
public function unterbrechung($prestudent_id, $studierendenantrag_id = null)
{
$this->load->view('lehre/Antrag/Create', [
'prestudent_id' => $prestudent_id,
'studierendenantrag_id' => $studierendenantrag_id,
'antrag_type' => 'Unterbrechung'
]);
}
public function wiederholung($prestudent_id, $studierendenantrag_id = null)
{
$this->load->view('lehre/Antrag/Create', [
'prestudent_id' => $prestudent_id,
'studierendenantrag_id' => $studierendenantrag_id,
'antrag_type' => 'Wiederholung'
]);
}
/**
* Checks if the caller is allowed to access to this content with the given permissions
* If it is not allowed will set the HTTP header with code 401
* Wrapper for permissionlib->isEntitled
*/
private function _isAllowed($requiredPermissions)
{
// Loads permission lib
$this->load->library('PermissionLib');
// Checks if this user is entitled to access to this content
if (!$this->permissionlib->isEntitled($requiredPermissions, $this->router->method))
{
$this->output->set_status_header(REST_Controller::HTTP_UNAUTHORIZED); // set the HTTP header as unauthorized
$this->load->library('EPrintfLib'); // loads the EPrintfLib to format the output
// Prints the main error message
$this->eprintflib->printError('You are not allowed to access to this content');
// Prints the called controller name
$this->eprintflib->printInfo('Controller name: '.$this->router->class);
// Prints the called controller method name
$this->eprintflib->printInfo('Method name: '.$this->router->method);
// Prints the required permissions needed to access to this method
$this->eprintflib->printInfo('Required permissions: '.$this->_rpsToString($requiredPermissions, $this->router->method));
exit; // immediately terminate the execution
}
}
/**
* Converts an array of permissions to a string that contains them as a comma separated list
* Ex: "<permission 1>, <permission 2>, <permission 3>"
*/
private function _rpsToString($requiredPermissions, $method)
{
$strRequiredPermissions = ''; // string that contains all the required permissions needed to access to this method
if (isset($requiredPermissions[$method])) // if the called method is present in the permissions array
{
// If it is NOT then convert it into an array
$rpsMethod = $requiredPermissions[$method];
if (!is_array($rpsMethod))
{
$rpsMethod = array($rpsMethod);
}
// Copy all the permissions into $strRequiredPermissions separated by a comma
for ($i = 0; $i < count($rpsMethod); $i++)
{
$strRequiredPermissions .= $rpsMethod[$i].', ';
}
$strRequiredPermissions = rtrim($strRequiredPermissions, ', ');
}
return $strRequiredPermissions;
}
}