Compare commits

..

13 Commits

559 changed files with 8808 additions and 67760 deletions
-14
View File
@@ -1,14 +0,0 @@
<?php
if (! defined('BASEPATH')) exit('No direct script access allowed');
use CI3_Events as Events;
/**
* NOTE(chris): example:
Events::on('stv_conf_student', function (&$res) {
$res['test'] = [
'title' => 'TEST',
'component' => './Stv/Studentenverwaltung/Details/Notizen.js'
];
});
*/
+5 -6
View File
@@ -6,6 +6,10 @@ if (! defined('BASEPATH')) exit('No direct script access allowed');
// Deadline for Application given as Time-Interval after Semesterstart.
$config['interval_blocking_application'] = 'P1M';
// Application submission period given by start- and enddate.
$config['submit_application_start'] = '05.09.2022';
$config['submit_application_end'] = '22.09.2022';
// Lehrveranstaltungen with these grades will be blocked for application
$config['grades_blocking_application'] = array(
5, // nicht genügend
@@ -15,9 +19,4 @@ $config['grades_blocking_application'] = array(
14, // nicht bestanden,
15, // nicht teilgenommen
18 // unentschuldigt
);
//Enables Fachbereichsleiter instead of LV Leiter
$config['fbl'] = FALSE;
//Enables Info Mails
$config['send_mail'] = TRUE;
);
-29
View File
@@ -1,29 +0,0 @@
<?php
/**
* Copyright (C) 2023 fhcomplete.org
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
if (!defined('BASEPATH')) exit('No direct script access allowed');
// NOTE: if database encryption is _not_ used then leave this array empty!
$config['encryption_passwords'] = array(
// 'password name 1' => 'password 1'
// 'password name 2' => 'password 2'
// 'password name ...' => 'password ...'
// 'password name N' => 'password N'
);
+3 -35
View File
@@ -31,14 +31,6 @@ $config['navigation_header'] = array(
'expand' => true,
'sort' => 20,
'requiredPermissions' => 'admin:w'
),
'bismeldestichtagsverwaltung' => array(
'link' => site_url('codex/Bismeldestichtag'),
'icon' => '',
'description' => 'BIS-Meldestichtagsverwaltung',
'expand' => true,
'sort' => 30,
'requiredPermissions' => 'admin:w'
)
)
),
@@ -172,14 +164,7 @@ $config['navigation_header'] = array(
'expand' => true,
'sort' => 20,
'requiredPermissions' => 'system/developer:r'
),
'anrechnungen' => array(
'link' => site_url('lehre/anrechnung/AdminAnrechnung'),
'description' => 'Anrechnungen',
'expand' => true,
'sort' => 30,
'requiredPermissions' => 'lehre/anrechnungszeitfenster:rw'
)
)
)
)
)
@@ -199,15 +184,6 @@ $config['navigation_menu']['Vilesci/index'] = array(
)
);
$config['navigation_menu']['Vilesci/index'] = array(
'dashboard' => array(
'link' => '#',
'description' => 'Dashboard',
'icon' => 'dashboard',
'sort' => 1
)
);
$config['navigation_menu']['organisation/Reihungstest/index'] = array(
'reihungstestverwalung' => array(
'link' => base_url('vilesci/stammdaten/reihungstestverwaltung.php'),
@@ -291,18 +267,10 @@ $config['navigation_menu']['system/issues/Issues/*'] = array(
'fehlerzustaendigkeiten' => array(
'link' => site_url('system/issues/IssuesZustaendigkeiten'),
'description' => 'Fehler Zuständigkeiten',
'icon' => 'users',
'icon' => 'cogs',
'sort' => 100,
'target' => '_blank',
'requiredPermissions' => array('admin:rw')
),
'fehlerkonfiguration' => array(
'link' => site_url('system/issues/IssuesKonfiguration'),
'description' => 'Fehler Konfiguration',
'icon' => 'cogs',
'sort' => 200,
'target' => '_blank',
'requiredPermissions' => array('admin:rw')
),
)
);
-170
View File
@@ -1,170 +0,0 @@
<?php
if (! defined('BASEPATH')) exit('No direct script access allowed');
$config['frist_rueckzahlung_studiengebuer_WS'] = '15.10.';
$config['frist_rueckzahlung_studiengebuer_SS'] = '15.03.';
// TODO(chris): review this!
#$config['unterbrechung_dms'] = ['oe_kurzbz' => null, 'dokument_kurzbz' => null, 'kategorie_kurzbz' => null];
$config['unterbrechung_dms'] = ['oe_kurzbz' => null, 'dokument_kurzbz' => null, 'kategorie_kurzbz' => 'Akte'];
/**
* UPLOAD
*/
/**
* Allowed filetypes for attachment upload in unterbrechung antrag
*
* @var array An array of fileextensions
*/
$config['unterbrechung_dms_filetypes'] = ['jpg', 'pdf'];
/**
* GRADES
*/
/**
* On wiederholung the student must repeat certain lvs.
* This lvs will be graded with this id
*
* @var integer tbl_note.note
*/
$config['wiederholung_note_angerechnet'] = 19;
/**
* On wiederholung the student can not attend certain lvs.
* Those lvs will be graded with this id
*
* @var integer tbl_note.note
*/
$config['wiederholung_note_nicht_zugelassen'] = 20;
/**
* JOBS
*/
/**
* The Job will remind for every Unterbrecher who has a
* wiedereinstieg_datum between the date the Job is run
* and the modified date
* e.g.: If the Job is running on 2023-04-20 and the modifier
* is '+3 days' it will remind of everyone that
* has a wiedereinstiegs_datum between 2023-04-20 and 2023-04-23
*
* @var string A string formated as PHP DateTime modifier
* @see https://www.php.net/manual/de/datetime.modify.php
*/
$config['unterbrechung_job_remind_wiedereinstieg_date_modifier'] = '+3 days';
/**
* The Job will sent a request to everyone who faild the 3rd committee exam
* and respecting the given conditions (not repeated yet, stg not in blacklist)
* to decide if he/she will repeat or not
*
* First request
*
* @var string A string formated as PHP DateTime modifier
* @see https://www.php.net/manual/de/datetime.modify.php
*/
$config['wiederholung_job_request_1_date_modifier'] = '+0 days';
/**
* Second request
*
* @var string A string formated as PHP DateTime modifier
* @see https://www.php.net/manual/de/datetime.modify.php
*/
$config['wiederholung_job_request_2_date_modifier'] = '+3 weeks';
/**
* Final deadline - after this the student will be abgemeldet if he hasn't chosen yet
*
* @var string A string formated as PHP DateTime modifier
* @see https://www.php.net/manual/de/datetime.modify.php
*/
$config['wiederholung_job_deadline_date_modifier'] = '+1 month';
/**
* before this exam dates for Wiederholer will be ignored
*
* @var string A string formated as Date
*
*/
$config['digitalization_start'] = '2022-07-01';
/**
* Objection period - the student will be abgemeldet if he hasn't objected in this period
*
* @var string A string formated as PHP DateTime modifier
* @see https://www.php.net/manual/de/datetime.modify.php
*/
$config['abmeldung_job_deadline_date_modifier'] = '+2 weeks';
/**
* System User - uid of a user that is allowed to set prestudentstatus
*
* @var string
*/
$config['antrag_job_systemuser'] = '';
/**
* WHITELISTS
*/
/**
* List of stati who entitle a prestudent to create an Antrag
*
* @var array Array of tbl_status.status_kurzbz's
*/
$config['antrag_prestudentstatus_whitelist'] = ['Student', 'Diplomand'];
$config['antrag_prestudentstatus_whitelist_abmeldung'] = ['Student', 'Diplomand', 'Unterbrecher'];
/**
* BLACKLISTS
*/
/**
* List of Statusgründe that prevent a prestudent from create an Wiederholungsantrag
*
* @var array An array of tbl_status_grund.statusgrund_id's
*/
$config['status_gruende_wiederholer'] = [16, 15];
/**
* Blacklisted for abmeldung anträge
*
* @var array An array of tbl_studiengang.studiengang_kz's
*/
$config['stgkz_blacklist_abmeldung'] = [];
/**
* Blacklisted for unterbrechung anträge
*
* @var array An array of tbl_studiengang.studiengang_kz's
*/
$config['stgkz_blacklist_unterbrechung'] = [];
/**
* Blacklisted for wiederholung anträge
*
* @var array An array of tbl_studiengang.studiengang_kz's
*/
$config['stgkz_blacklist_wiederholung'] = [];
/**
* Blacklisted noten for negative committee exams
* noten with this ids won't be seen as negative
*
* @var array An array of noten ids
*/
$config['note_blacklist_wiederholung'] = [];
-16
View File
@@ -1,16 +0,0 @@
<?php
if ( !defined("PHPUNIT_TEST") ) {
show_404();
}
class Test extends CI_Controller
{
public function index()
{
// Yep... This is all we need.
ini_set('error_reporting', E_ALL); // or error_reporting(E_ALL);
ini_set('display_errors', '1');
ini_set('display_startup_errors', '1');
}
}
@@ -1,140 +0,0 @@
<?php
if (! defined('BASEPATH')) exit('No direct script access allowed');
/**
* Overview on Bismeldestichtage
*/
class Bismeldestichtag extends Auth_Controller
{
/**
* Constructor
*/
public function __construct()
{
parent::__construct(
array(
'index' => 'admin:r',
'getStudiensemester' => 'admin:r',
'getBismeldestichtage' => 'admin:r',
'addBismeldestichtag' => 'admin:rw',
'deleteBismeldestichtag' => 'admin:rw'
)
);
// Load models
$this->load->model('codex/Bismeldestichtag_model', 'BismeldestichtagModel');
$this->load->model('organisation/Studiensemester_model', 'StudiensemesterModel');
// Loads phrases system
$this->loadPhrases(
array(
'bismeldestichtag'
)
);
}
// -----------------------------------------------------------------------------------------------------------------
// Public methods
/**
* Everything has a beginning
*/
public function index()
{
$this->load->view('codex/bismeldestichtag.php');
}
public function getStudiensemester()
{
// load semester list
$semList = array();
$this->StudiensemesterModel->addSelect('studiensemester_kurzbz');
$this->StudiensemesterModel->addOrder('start', 'DESC');
$semRes = $this->StudiensemesterModel->load();
if (hasData($semRes))
{
$semList = getData($semRes);
}
// load current semester
$currSem = null;
$semRes = $this->StudiensemesterModel->getAkt();
if (hasData($semRes))
{
$currSem = getData($semRes)[0]->studiensemester_kurzbz;
}
// output data
$this->outputJsonSuccess(
array('semList' => $semList, 'currSem' => $currSem)
);
}
public function getBismeldestichtage()
{
$this->BismeldestichtagModel->addSelect(
'meldestichtag_id, meldestichtag,
tbl_bismeldestichtag.studiensemester_kurzbz, sem.start AS semester_start,
tbl_bismeldestichtag.insertamum, tbl_bismeldestichtag.insertvon, tbl_bismeldestichtag.updateamum, tbl_bismeldestichtag.updatevon'
);
$this->BismeldestichtagModel->addJoin('public.tbl_studiensemester sem', 'studiensemester_kurzbz', 'LEFT');
$this->BismeldestichtagModel->addOrder('semester_start');
$this->BismeldestichtagModel->addOrder('meldestichtag', 'DESC');
$this->BismeldestichtagModel->addOrder('meldestichtag_id', 'DESC');
$this->outputJson($this->BismeldestichtagModel->load());
}
public function addBismeldestichtag()
{
// get request data
$request = $this->getPostJSON();
// check request data
if (!property_exists($request, 'meldestichtag') || isEmptyString($request->meldestichtag))
$this->terminateWithJsonError('Error occured: Meldestichtag missing');
if (!property_exists($request, 'studiensemester_kurzbz') || isEmptyString($request->studiensemester_kurzbz))
$this->terminateWithJsonError('Error occured: Studiensemester missing');
$meldestichtag = $request->meldestichtag;
$studiensemester_kurzbz = $request->studiensemester_kurzbz;
// check if Bismeldestichtag already exists
$this->BismeldestichtagModel->addSelect('1');
$bismeldestichtagRes = $this->BismeldestichtagModel->loadWhere(
array('meldestichtag' => $meldestichtag, 'studiensemester_kurzbz' => $studiensemester_kurzbz)
);
// return success if already exists
if (hasData($bismeldestichtagRes))
$this->outputJsonSuccess('Bismeldestichtag already exists');
else
{
// insert new if Stichtag does not exist
$this->outputJson($this->BismeldestichtagModel->insert(
array(
'meldestichtag' => $request->meldestichtag,
'studiensemester_kurzbz' => $request->studiensemester_kurzbz,
'insertvon' => getAuthUID()
)
));
}
}
public function deleteBismeldestichtag()
{
// get request data
$request = $this->getPostJSON();
// check request data
if (!property_exists($request, 'meldestichtag_id'))
$this->terminateWithJsonError('Error occured: Meldestichtag Id missing');
$meldestichtag_id = $request->meldestichtag_id;
// deletetion
$this->outputJson($this->BismeldestichtagModel->delete($meldestichtag_id));
}
}
-438
View File
@@ -1,438 +0,0 @@
<?php
if (! defined("BASEPATH")) exit("No direct script access allowed");
class UHSTAT1 extends FHC_Controller
{
const BERECHTIGUNG_UHSTAT_VERWALTEN = 'student/uhstat1daten_verwalten';
const PERSON_ID_SESSION_INDEX = 'bewerbung/personId';
const CODEX_OESTERREICH = 'A';
const LOWER_BOUNDARY_YEARS = 160;
const UPPER_BOUNDARY_YEARS = 20;
private $_uid;
private $_uhstat1Fields = array();
public function __construct()
{
parent::__construct();
// load ci libs
$this->load->library('form_validation');
// load ci helpers
$this->load->helper(array('form', 'url'));
// load libraries
$this->load->library('AuthLib');
$this->load->library('PermissionLib');
// load models
$this->load->model('codex/Oehbeitrag_model', 'OehbeitragModel');
$this->load->model('organisation/Studiensemester_model', 'StudiensemesterModel');
$this->load->model('system/Sprache_model', 'SpracheModel');
$this->load->model('codex/Abschluss_model', 'AbschlussModel');
$this->load->model('codex/Uhstat1daten_model', 'Uhstat1datenModel');
$this->loadPhrases(
array(
'ui',
'uhstat'
)
);
$this->_uid = getAuthUID();
// set form field information
$this->_uhstat1Fields = array(
'mutter_geburtsstaat' => array('name' => 'Geburtsstaat Mutter'),
'mutter_geburtsjahr' => array('name' => 'Geburtsjahr Mutter'),
'mutter_bildungsstaat' => array('name' => 'Bildungsstaat Mutter'),
'mutter_bildungmax' => array(
'name' => 'Geburtsjahr Mutter',
'rules' => array(
'callback_bildungsstaat_bildungmax_check[m]' => array(
'bildungsstaat_bildungmax_check' => $this->p->t('uhstat', 'ausbildungBildungsstaatUebereinstimmung')
)
)
),
'vater_geburtsstaat' => array('name' => 'Geburtsstaat Vater'),
'vater_geburtsjahr' => array('name' => 'Geburtsjahr Vater'),
'vater_bildungsstaat' => array('name' => 'Bildungsstaat Vater'),
'vater_bildungmax' => array('name' => 'Geburtsjahr Vater'),
'vater_bildungmax' => array(
'name' => 'Geburtsjahr Vater',
'rules' => array(
'callback_bildungsstaat_bildungmax_check[v]' => array(
'bildungsstaat_bildungmax_check' => $this->p->t('uhstat', 'ausbildungBildungsstaatUebereinstimmung')
)
)
)
);
}
// -----------------------------------------------------------------------------------------------------------------
// Public methods
public function index()
{
$formMetaData = $this->_getFormMetaData();
if (isError($formMetaData)) show_error(getError($formMetaData));
if (!hasData($formMetaData)) show_error("No form meta data could be loaded");
$uhstatData = $this->_getUHSTAT1Data();
if (isError($uhstatData)) show_error(getError($uhstatData));
$this->load->view("codex/uhstat1.php", array(
'formMetaData' => getData($formMetaData),
'uhstatData' => getData($uhstatData)
)
);
}
/**
* Add or update UHSTAT1 data
*/
public function saveUHSTAT1Data()
{
$saved = false;
$person_id = $this->_getValidPersonId('sui');
$this->form_validation->set_error_delimiters('<span class="text-danger">', '</span>');
foreach ($this->_uhstat1Fields as $field => $params)
{
// all fields are required
$ruleNames = 'required';
$ruleMessages = array('required' => $this->p->t('uhstat', 'angabeFehlt'));
// add additional rules
if (isset($params['rules']))
{
foreach ($params['rules'] as $ruleName => $ruleMessage)
{
$ruleNames .= '|'.$ruleName;
$ruleMessages = array_merge($ruleMessages, $ruleMessage);
}
}
$this->form_validation->set_rules(
$field,
$params['name'],
$ruleNames,
$ruleMessages
);
}
$uhstat1datenRes = null;
if ($this->form_validation->run()) // if valid
{
// get post fields
$uhstatData = array();
foreach ($this->_uhstat1Fields as $field => $params)
{
$uhstatData[$field] = $this->input->post($field);
}
// check if entry already exists
$uhstat1datenloadRes = $this->Uhstat1datenModel->loadWhere(array('person_id' => $person_id));
// if yes, update
if (hasData($uhstat1datenloadRes))
{
$uhstatData['updateamum'] = 'NOW()';
$uhstatData['updatevon'] = $this->_uid;
$uhstat1datenRes = $this->Uhstat1datenModel->update(
array('person_id' => $person_id),
$uhstatData
);
}
else // otherwise insert
{
$uhstatData['insertamum'] = 'NOW()';
$uhstatData['insertvon'] = $this->_uid;
$uhstat1datenRes = $this->Uhstat1datenModel->insert(
array_merge($uhstatData, array('person_id' => $person_id))
);
}
}
$formMetaData = $this->_getFormMetaData();
if (isError($formMetaData)) show_error(getError($formMetaData));
if (!hasData($formMetaData)) show_error("No form meta data could be loaded");
$successMessage = '';
$errorMessage = '';
// pass success/error messages to view
if (isset($uhstat1datenRes))
{
if (isSuccess($uhstat1datenRes))
{
$successMessage = $this->p->t('uhstat', 'erfolgreichGespeichert');
$saved = true;
}
else
$errorMessage = $this->p->t('uhstat', 'fehlerBeimSpeichern');
}
// load view with form data
$this->load->view("codex/uhstat1.php", array(
'formMetaData' => getData($formMetaData),
'saved' => $saved,
'successMessage' => $successMessage,
'errorMessage' => $errorMessage
)
);
}
/**
* Check callback for Bildungsstaat - if Bildungsstaat is Austria, a highest education should be in Austria.
* @param $bildungmax
* @param $bildungsstaat_typ - mother (m) or father (v)
* @return bool true if valid, false otherwise
*/
public function bildungsstaat_bildungmax_check($bildungmax, $bildungsstaat_typ)
{
// valid if no type passed
if (!isset($bildungsstaat_typ) || !isset($bildungmax)) return true;
// get correct input
if ($bildungsstaat_typ == 'm') // mutter
$bildungsstaat = $this->input->post('mutter_bildungsstaat');
elseif ($bildungsstaat_typ == 'v') // vater
$bildungsstaat = $this->input->post('vater_bildungsstaat');
else
return true;
if (!isset($bildungsstaat)) return true;
// find out if abschluss is in Austria
$this->AbschlussModel->addSelect("in_oesterreich");
$abschlussRes = $this->AbschlussModel->load($bildungmax);
if (hasData($abschlussRes))
{
$in_oesterreich = getData($abschlussRes)[0]->in_oesterreich;
// invalid if abschluss in Austria, but not Bildungsstaat, or abschluss not in Austria, but Bildungsstaat in Austria
return ($in_oesterreich && $bildungsstaat == self::CODEX_OESTERREICH) || (!$in_oesterreich && $bildungsstaat != self::CODEX_OESTERREICH);
}
return false;
}
/**
* Deletes UHSTAT1 entry.
*/
public function deleteUHSTAT1Data()
{
$saved = false;
// uhstat data can only be deleted with permission
if (!$this->_checkPermission('suid')) show_error('no permission');
$person_id = $this->_getValidPersonId('suid');
$uhstat1datenRes = $this->Uhstat1datenModel->delete(
array('person_id' => $person_id)
);
$formMetaData = $this->_getFormMetaData();
if (isError($formMetaData)) show_error(getError($formMetaData));
if (!hasData($formMetaData)) show_error("No form meta data could be loaded");
$successMessage = '';
$errorMessage = '';
// pass success/error messages to view
if (isset($uhstat1datenRes))
{
if (isSuccess($uhstat1datenRes))
{
$successMessage = $this->p->t('uhstat', 'erfolgreichGeloescht');
}
else
$errorMessage = $this->p->t('uhstat', 'fehlerBeimLoeschen');
}
// load view with form data
$this->load->view("codex/uhstat1.php", array(
'formMetaData' => getData($formMetaData),
'successMessage' => $successMessage,
'errorMessage' => $errorMessage
)
);
}
// -----------------------------------------------------------------------------------------------------------------
// Private methods
/**
* Gets initial data needed to display UHSTAT1 form.
*/
private function _getFormMetaData()
{
$person_id = $this->_getValidPersonId('s');
// read only display param
$readOnly = $this->input->get('readOnly');
// depending on permissions, editing or deleting is possible
$editPermission = $this->_checkPermission('sui');
$deletePermission = $this->_checkPermission('suid');
$languageIdx = $this->_getLanguageIndex();
$formMetaData = array(
'nation' => array(),
'abschluss_oesterreich' => array(),
'abschluss_nicht_oesterreich' => array(),
'jahre' => array(),
'person_id' => $person_id,
'editPermission' => $editPermission,
'deletePermission' => $deletePermission,
'readOnly' => $readOnly
);
// get person data
$this->load->model('person/Person_model', 'PersonModel');
$this->PersonModel->addSelect("vorname, nachname");
$personRes = $this->PersonModel->load($person_id);
if (isError($personRes)) return $personRes;
if (hasData($personRes))
{
$person = getData($personRes)[0];
$formMetaData['vorname'] = $person->vorname;
$formMetaData['nachname'] = $person->nachname;
}
$nationTextFieldName = $languageIdx == 1 ? 'langtext' : 'engltext';
// get nation list
$this->load->model('codex/Nation_model', 'NationModel');
$this->NationModel->addSelect("nation_code, $nationTextFieldName AS nation_text");
$this->NationModel->addOrder("nation_text");
$nationRes = $this->NationModel->loadWhere('sperre IS NULL OR sperre = FALSE');
if (isError($nationRes)) return $nationRes;
if (hasData($nationRes))
{
$nations = getData($nationRes);
// put austria in beginning of selection
foreach ($nations as $nation)
{
if ($nation->nation_code == self::CODEX_OESTERREICH) array_unshift($nations, $nation);
}
$formMetaData['nation'] = $nations;
}
// get abschluss list
$abschlussRes = $this->AbschlussModel->getActiveAbschluesse($languageIdx);
if (isError($abschlussRes)) return $abschlussRes;
$abschlussData = getData($abschlussRes);
if (hasData($abschlussRes))
{
foreach (getData($abschlussRes) as $abschluss)
{
if ($abschluss->in_oesterreich === true)
$formMetaData['abschluss_oesterreich'][] = $abschluss;
elseif ($abschluss->in_oesterreich === false)
$formMetaData['abschluss_nicht_oesterreich'][] = $abschluss;
else
{
$formMetaData['abschluss_oesterreich'][] = $abschluss;
$formMetaData['abschluss_nicht_oesterreich'][] = $abschluss;
}
}
}
// get realistic birth years, dated back from current year
$currYear = date("Y");
$formMetaData['jahre'] = range($currYear - self::UPPER_BOUNDARY_YEARS, $currYear - self::LOWER_BOUNDARY_YEARS);
return success($formMetaData);
}
/**
* Gets initial data needed to display UHSTAT1 form.
*/
private function _getUHSTAT1Data()
{
$person_id = $this->_getValidPersonId('s');
$this->Uhstat1datenModel->addSelect(
implode(', ', array_keys($this->_uhstat1Fields))
);
$uhstatRes = $this->Uhstat1datenModel->loadWhere(array('person_id' => $person_id));
if (isError($uhstatRes)) return $uhstatRes;
return success(hasData($uhstatRes) ? getData($uhstatRes)[0] : null);
}
/**
* Gets language index of currently logged in user.
* @return int (the index, start at 1)
*/
private function _getLanguageIndex()
{
$idx = 1;
$this->SpracheModel->addSelect('index');
$langRes = $this->SpracheModel->loadWhere(array('sprache' => getUserLanguage()));
if (hasData($langRes))
{
$idx = getData($langRes)[0]->index;
}
return $idx;
}
/**
* Gets Id of person having permissions to manage UHSTAT1 data.
* Can be passed as parameter or be in session.
* @return int person_id
*/
private function _getValidPersonId($berechtigungsArt)
{
// if coming from bewerbungstool - person id is in session (person must be logged in bewerbungstool)
if (isset($_SESSION[self::PERSON_ID_SESSION_INDEX]) && is_numeric($_SESSION[self::PERSON_ID_SESSION_INDEX]))
return $_SESSION[self::PERSON_ID_SESSION_INDEX];
// if person id passed directly...
$person_id = $this->input->post('person_id');
if (!isset($person_id)) $person_id = $this->input->get('person_id');
if (!isset($person_id) || !is_numeric($person_id)) show_error("invalid person id");
// ...check if there is a permission for editing UHSTAT1 data
if ($this->_checkPermission($berechtigungsArt)) return $person_id;
show_error("No permission");
}
/**
* Checks if logged user has the UHSTAT management permission.
* @param $art - type of permission, e.g. suid for full permissions
* @return bool
*/
private function _checkPermission($art)
{
return $this->permissionlib->isBerechtigt(self::BERECHTIGUNG_UHSTAT_VERWALTEN, $art);
}
}
@@ -1,218 +0,0 @@
<?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,
Studierendenantrag_model::TYP_ABMELDUNG_STGL
]
);
if (isError($result)) {
return $this->outputJsonError(getError($result));
}
$data = getData($result);
$data->canCancel = (
$data->status == Studierendenantragstatus_model::STATUS_CREATED &&
$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 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_ABMELDUNG_STGL && $data->typ !== Studierendenantrag_model::TYP_ABMELDUNG)
return show_404();
$data->canCancel = (
$data->status == Studierendenantragstatus_model::STATUS_CREATED &&
$this->antraglib->isEntitledToCancelAntrag($data->studierendenantrag_id)
);
$this->outputJsonSuccess($data);
}
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');
$_POST = json_decode($this->input->raw_input_stream, true);
$query = $this->input->post('query');
$studiengaenge = $this->permissionlib->getSTG_isEntitledFor('student/studierendenantrag');
$result = $this->antraglib->getAktivePrestudentenInStgs($studiengaenge, $query);
if (isError($result)) {
return $this->outputJsonError(getError($result));
}
$result = getData($result);
if (!$result) {
return $this->outputJsonSuccess([]);
}
return $this->outputJsonSuccess($result);
}
}
@@ -1,479 +0,0 @@
<?php
if (! defined('BASEPATH')) exit('No direct script access allowed');
use \stdClass as stdClass;
/**
*
*/
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 getActiveStgs()
{
$studiengaenge = $this->permissionlib->getSTG_isEntitledFor('student/antragfreigabe') ?: [];
$studiengaenge = array_merge($studiengaenge, $this->permissionlib->getSTG_isEntitledFor('student/studierendenantrag') ?: []);
$result = $this->StudierendenantragModel->loadStgsWithAntraege($studiengaenge);
if (isError($result)) {
$this->output->set_status_header(REST_Controller::HTTP_INTERNAL_SERVER_ERROR);
}
$this->outputJson($result);
}
public function getAntraege($studiengang = null, $extra = null)
{
if ($studiengang && $studiengang == 'todo') {
$studiengang = $extra;
$extra = true;
} else {
$extra = false;
}
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 = $extra
? $this->StudierendenantragModel->loadActiveForStudiengaenge($studiengaenge)
: $this->StudierendenantragModel->loadForStudiengaenge($studiengaenge);
if (isError($result)) {
$this->output->set_status_header(500);
return $this->outputJson('Internal Server Error');
}
if(hasData($result))
{
$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 pauseAntrag()
{
$this->load->library('form_validation');
$_POST = json_decode($this->input->raw_input_stream, true);
$this->form_validation->set_rules(
'studierendenantrag_id',
'Studierenden Antrag',
[
'required',
[
'isEntitledToPauseAntrag',
[$this->antraglib, 'isEntitledToPauseAntrag']
],
[
'antragCanBeManualPaused',
[$this->antraglib, 'antragCanBeManualPaused']
]
],
[
'isEntitledToPauseAntrag' => $this->p->t('studierendenantrag', 'error_no_right'),
'antragCanBeManualPaused' => $this->p->t(
'studierendenantrag',
'error_not_pauseable',
['id' => $this->input->post('studierendenantrag_id')]
)
]
);
if ($this->form_validation->run() == false)
{
return $this->outputJsonError($this->form_validation->error_array());
}
$studierendenantrag_id = $this->input->post('studierendenantrag_id');
$result = $this->antraglib->pauseAntrag($studierendenantrag_id, getAuthUID());
if (isError($result))
return $this->outputJsonError(['studierendenantrag_id' => getError($result)]);
$this->outputJsonSuccess($studierendenantrag_id);
}
public function unpauseAntrag()
{
$this->load->library('form_validation');
$_POST = json_decode($this->input->raw_input_stream, true);
$this->form_validation->set_rules(
'studierendenantrag_id',
'Studierenden Antrag',
[
'required',
[
'isEntitledToUnpauseAntrag',
[$this->antraglib, 'isEntitledToUnpauseAntrag']
],
[
'antragCanBeManualUnpaused',
[$this->antraglib, 'antragCanBeManualUnpaused']
]
],
[
'isEntitledToUnpauseAntrag' => $this->p->t('studierendenantrag', 'error_no_right'),
'antragCanBeManualUnpaused' => $this->p->t(
'studierendenantrag',
'error_not_paused',
['id' => $this->input->post('studierendenantrag_id')]
)
]
);
if ($this->form_validation->run() == false)
{
return $this->outputJsonError($this->form_validation->error_array());
}
$studierendenantrag_id = $this->input->post('studierendenantrag_id');
$result = $this->antraglib->unpauseAntrag($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');
$grund = $this->input->post('grund');
$result = $this->antraglib->denyObjectionAbmeldung($studierendenantrag_id, getAuthUID(), $grund);
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->hasType($studierendenantrag_id, Studierendenantrag_model::TYP_ABMELDUNG_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 approveAbmeldungStgl()
{
return $this->approveAbmeldung();
}
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) ?: []);
}
}
@@ -1,233 +0,0 @@
<?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',
'ui'
]);
}
//------------------------------------------------------------------------------------------------------------------
// 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($prestudent_id, null);
$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, $studiensemester, $datum_wiedereinstieg);
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);
}
}
@@ -1,384 +0,0 @@
<?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([
'global',
'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) {
$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, $data->datum, $data->studiensemester_kurzbz);
// 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)
{
return $this->outputJsonError(['db' => $this->p->t('studierendenantrag', 'error_no_student')]);
}
elseif ($result == -1)
{
$result = $this->PrestudentstatusModel->getLastStatus($prestudent_id);
if (isError($result))
return $this->outputJsonError(['db' => getError($result)]);
if (!hasData($result))
return $this->outputJsonError(['db' => $this->p->t('studierendenantrag', 'error_no_prestudentstatus', [
'prestudent_id' => $prestudent_id
])]);
if (!in_array(current(getData($result))->status_kurzbz, $this->config->item('antrag_prestudentstatus_whitelist')))
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
]);
}
}
@@ -26,9 +26,6 @@ class Filter extends FHC_Controller
// Loads authentication library and starts authentication
$this->load->library('AuthLib');
// Loads the FiltersModel
$this->load->model('system/Filters_model', 'FiltersModel');
// Loads the FilterCmptLib with HTTP GET/POST parameters
$this->_startFilterCmptLib();
}
@@ -1,22 +0,0 @@
<?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()));
}
}
@@ -17,17 +17,8 @@ class SearchBar extends FHC_Controller
{
parent::__construct();
// Loads the AuthLib _without_ starting the authentication
// NOTE:
// - A user must be authenticated via another controller to access this one
// - It is loaded to be able to call the isLogged function later
$this->load->library('AuthLib');
// Load the library SearchBarLib
$this->load->library('SearchBarLib');
// Checks if the user is authenticated, otherwise returns an error code in JSON format
if (!isLogged()) $this->terminateWithJsonError(SearchBarLib::ERROR_NOT_AUTH);
}
//------------------------------------------------------------------------------------------------------------------
+6 -85
View File
@@ -37,9 +37,6 @@ class AnrechnungJob extends JOB_Controller
$this->load->helper('hlp_sancho_helper');
$this->load->library('AnrechnungLib');
// Load configs
$this->load->config('anrechnung');
}
/**
@@ -216,7 +213,7 @@ class AnrechnungJob extends JOB_Controller
'datentabelle' => $anrechnungen_table,
'link' => anchor($url, 'Anrechnungsanträge Übersicht')
);
// Send mail
sendSanchoMail(
'AnrechnungAntragStellen',
@@ -230,82 +227,6 @@ class AnrechnungJob extends JOB_Controller
$this->logInfo('SUCCEDED: Sending emails to STGL about yesterdays new Anrechnungen succeded.');
}
// Send Sancho mail to LV-Leitung (fallback Lectors) that were requested for recommendation yesterday.
public function sendMailRecommendationRequests(){
$this->logInfo('Start AnrechnungJob sendMailRecommendationRequests to inform lecturers about yesterdays requests for recommendation.');
// Get Anrechnungen, für die gestern eine Empfehlung angefragt worden ist
$this->AnrechnungModel->addSelect('astat.anrechnung_id, astat.datum, astat.insertamum');
$this->AnrechnungModel->addDistinct('astat.anrechnung_id');
$this->AnrechnungModel->addJoin('lehre.tbl_anrechnung_anrechnungstatus astat', 'anrechnung_id');
$result = $this->AnrechnungModel->loadWhere('
studiensemester_kurzbz = (SELECT studiensemester_kurzbz FROM tbl_studiensemester WHERE now()::date BETWEEN start AND ende)
AND genehmigt_von IS NULL
AND empfehlung_anrechnung IS NULL
AND status_kurzbz = '. $this->db->escape(self::ANRECHNUNGSTATUS_PROGRESSED_BY_LEKTOR) .' -- in Bearbeitung durch Lektor
AND NOW()::date = (astat.datum + interval \'1 day\') -- nur gestrige Empfehlungsanfrage
ORDER BY astat.anrechnung_id, astat.datum DESC, astat.insertamum DESC -- nur letzten status dabei prüfen
');
// Exit, wenn es gestern keine Empfehlungsanfragen gab
if (!hasData($result))
{
$this->logInfo('End AnrechnungJob sendMailRecommendationRequests, because no recommendations were requested yesterday.');
exit;
}
$anrechnung_id_arr = array_column(getData($result), 'anrechnung_id');
$arr_lvLector_arr = array();
foreach ($anrechnung_id_arr as $anrechnung_id)
{
// Get full name of Fachbereichsleitung or LV Leitung.
if($this->config->item('fbl') === TRUE)
{
$arr_lvLector_arr[] = $this->anrechnunglib->getLeitungOfLvOe($anrechnung_id);
}
else
{
$arr_lvLector_arr[] = $this->anrechnunglib->getLectors($anrechnung_id); // Returns LV Leitung. If not present, then all lectors of LV.
}
}
// Unique lector array to send only one mail per lector
$arr_lvLector_arr = array_unique($arr_lvLector_arr, SORT_REGULAR);
// Link to 'Anrechnungen prüfen' dashboard
$url =
CIS_ROOT. 'cis/index.php?menu='.
CIS_ROOT. 'cis/menu.php?content_id=&content='.
CIS_ROOT. index_page(). self::REVIEW_ANRECHNUNG_URI;
foreach ($arr_lvLector_arr as $lvLector_arr)
{
foreach ($lvLector_arr as $lector)
{
// Prepare mail content
$fields = array(
'vorname' => $lector->vorname,
'stgl_name' => 'Die Studiengangsleitung',
'link' => anchor($url, 'Anrechnungsanträge Übersicht')
);
// Send mail
sendSanchoMail(
'AnrechnungEmpfehlungAnfordern',
$fields,
$lector->uid. '@'. DOMAIN,
'Deine Empfehlung wird benötigt zur Anerkennung nachgewiesener Kenntnisse'
);
}
}
$this->logInfo('SUCCEDED AnrechnungJob sendMailRecommendationRequests');
}
/**
* Send Sancho mail to students, whose Anrechnungen were approved 24 hours ago.
*/
@@ -387,7 +308,7 @@ class AnrechnungJob extends JOB_Controller
$db = new DB_Model();
$result = $db->execReadOnlyQuery($qry);
// Exit if there are no rejected Anrechnungen
if (!hasData($result))
{
@@ -440,9 +361,9 @@ html;
$result = $this->AnrechnungModel->loadWhere('
studiensemester_kurzbz = (
SELECT studiensemester_kurzbz FROM tbl_studiensemester WHERE now()::date BETWEEN start AND ende
SELECT studiensemester_kurzbz FROM tbl_studiensemester WHERE now()::date BETWEEN start AND ende)
)
AND genehmigt_von IS NULL
AND genehmigt_von IS NULL
AND empfehlung_anrechnung IS NULL
AND status_kurzbz = '. $this->db->escape(self::ANRECHNUNGSTATUS_PROGRESSED_BY_LEKTOR) .' -- in Bearbeitung durch Lektor
AND NOW()::date = (astat.datum + interval \'1 week\') -- eine Woche nach Empfehlungsanfrage
@@ -455,7 +376,7 @@ html;
$this->logInfo('End AnrechnungJob sendMailRemindRecommendation, because no recommendations to be done.');
exit;
}
$anrechnung_id_arr = array_column(getData($result), 'anrechnung_id');
$arr_lvLector_arr = array();
@@ -514,7 +435,7 @@ html;
'vorname' => $stgl->vorname
);
}
return $stglMailAdress_arr;
}
// If not available, get assistance mail address
-689
View File
@@ -1,689 +0,0 @@
<?php
if (!defined("BASEPATH")) exit("No direct script access allowed");
use \DateTime as DateTime;
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');
$this->load->library('AntragLib');
// 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');
$this->load->model('crm/Student_model', 'StudentModel');
$this->load->model('organisation/Studiengang_model', 'StudiengangModel');
$this->load->model('organisation/Studiensemester_model', 'StudiensemesterModel');
}
/**
* Send infomail to Stgl
*/
public function sendStglSammelmail()
{
$this->load->model('person/Person_model', 'PersonModel');
$this->logInfo('Start Job sendStglSammelmail');
$this->load->model('organisation/Studiengang_model', 'StudiengangModel');
$this->StudierendenantragModel->addJoin('public.tbl_prestudent', 'prestudent_id');
$this->db->group_start();
$this->db->where('typ', Studierendenantrag_model::TYP_ABMELDUNG);
$this->db->where('campus.get_status_studierendenantrag(studierendenantrag_id)', Studierendenantragstatus_model::STATUS_CREATED);
$this->db->group_end();
$this->db->or_group_start();
$this->db->where('typ', Studierendenantrag_model::TYP_ABMELDUNG_STGL);
$this->db->where('campus.get_status_studierendenantrag(studierendenantrag_id)', Studierendenantragstatus_model::STATUS_CREATED);
$this->db->group_end();
$this->db->or_group_start();
$this->db->where('typ', Studierendenantrag_model::TYP_UNTERBRECHUNG);
$this->db->where('campus.get_status_studierendenantrag(studierendenantrag_id)', Studierendenantragstatus_model::STATUS_CREATED);
$this->db->group_end();
$this->db->or_group_start();
$this->db->where('typ', Studierendenantrag_model::TYP_WIEDERHOLUNG);
$this->db->where('campus.get_status_studierendenantrag(studierendenantrag_id)', Studierendenantragstatus_model::STATUS_LVSASSIGNED);
$this->db->group_end();
$result = $this->StudierendenantragModel->load();
if(isError($result))
return $this->logError(getError($result));
if(!hasData($result))
return $this->logInfo('End Job sendStglSammelmail: 0 Mails sent');
$antraege = getData($result);
$stgs = array();
$stgLeitungen = array();
foreach ($antraege as $antrag)
{
if (!isset($stgs[$antrag->studiengang_kz]))
{
$result = $this->StudiengangModel->getLeitung($antrag->studiengang_kz);
if (isError($result))
{
$this->logError(getError($result));
continue;
}
if (!hasData($result))
{
$this->logError('Keine Leitung für Studiengang ' . $antrag->studiengang_kz . ' gefunden!');
continue;
}
$leitung = current(getData($result));
if (!isset($stgLeitungen[$leitung->uid]))
{
$stgLeitungen[$leitung->uid] = [ 'Details' => $leitung, 'stgs' => [] ];
}
$stgLeitungen[$leitung->uid]['stgs'][] = $antrag->studiengang_kz;
$result = $this->StudierendenantragModel->getStgAndSem($antrag->studierendenantrag_id);
if (isError($result))
{
$this->logError(getError($result));
continue;
}
if (!hasData($result))
{
$this->logError('Keine Details für Studiengang ' . $antrag->studiengang_kz . ' gefunden!');
continue;
}
$details = current(getData($result));
$stgs[$antrag->studiengang_kz] = [
'Abmeldung' => [],
'Unterbrechung' => [],
'Wiederholung' => [],
'Details' => $details
];
}
$stgs[$antrag->studiengang_kz][str_replace('Stgl', '', $antrag->typ)] = $antrag;
}
$this->load->model('system/Sprache_model', 'SpracheModel');
$result = $this->SpracheModel->loadWhere(['content' => true]);
if (isError($result)) {
$this->logError(getError($result));
$languages = [DEFAULT_LANGUAGE];
} elseif (!hasData($result)) {
$languages = [DEFAULT_LANGUAGE];
} else {
$languages = array_map(function ($row) {
return $row->sprache;
}, getData($result));
}
$count = 0;
foreach ($stgLeitungen as $leitung)
{
$data = [
'name' => trim($leitung['Details']->vorname . ' ' . $leitung['Details']->nachname),
'vorname' => $leitung['Details']->vorname,
'nachname' => $leitung['Details']->nachname
];
foreach ($languages as $lang) {
unset($this->p);
$this->loadPhrases(['studierendenantrag'], $lang);
$table = '';
foreach ($leitung['stgs'] as $studiengang_kz) {
$rows = '';
$stg = $stgs[$studiengang_kz];
foreach (['Abmeldung', 'Unterbrechung', 'Wiederholung'] as $typ) {
$c = count($stg[$typ]);
if ($c) {
$rows .= $this->p->t('studierendenantrag', 'mail_part_x_new_' . $typ, ['count' => $c]);
}
}
$table .= $this->p->t('studierendenantrag', 'mail_part_table', [
'stg_bezeichnung' => $stg['Details']->bezeichnung,
'stg_orgform_kurzbz' => $stg['Details']->orgform_kurzbz,
'rows' => $rows
]);
}
$data['table_' . $lang] = $table;
}
$data['table'] = $data['table_' . DEFAULT_LANGUAGE];
$data['leitungLink'] = APP_ROOT. 'index.ci.php/lehre/Studierendenantrag/leitung';
//Mail an Stgl und Assistenz
$to = $leitung['Details']->uid . '@' . DOMAIN;
$cc = $leitung['Details']->email;
// NOTE(chris): Sancho mail
if (sendSanchoMail(
"Sancho_Mail_Antrag_Stgl",
$data,
$to,
'Anträge - Aktion(en) erforderlich',
DEFAULT_SANCHO_HEADER_IMG,
DEFAULT_SANCHO_FOOTER_IMG,
'',
$cc
))
$count++;
}
$this->logInfo($count . " Emails erfolgreich versandt");
$this->logInfo('End Job sendStglSammelmail');
}
/**
* 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)
{
$res = $this->StudierendenantragModel->getStgAndSem($antrag->studierendenantrag_id);
$stg = '';
$orgform = '';
if (hasData($res)) {
$studiengang = current(getData($res));
$stg = $studiengang->bezeichnung;
$orgform = $studiengang->orgform_kurzbz;
}
$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'),
'vorname' => $antrag->vorname,
'nachname' => $antrag->nachname,
'Orgform' => $orgform,
'stg' => $stg
);
$result = $this->StudentModel->loadWhere(['prestudent_id'=> $antrag->prestudent_id]);
if (hasData($result)) {
$student = current(getData($result));
$data['UID'] = $student->student_uid;
}
// NOTE(chris): Sancho mail
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;
}
$digi_start= $this->config->item('digitalization_start');
if($digi_start)
$digi_start = new DateTime($digi_start);
$dateDeadline = new DateTime();
$dateDeadline->sub(DateInterval::createFromDateString($modifier_deadline));
$result = $this->PruefungModel->getAllPrestudentsWhereCommitteeExamFailed(
[
Studierendenantragstatus_model::STATUS_REQUESTSENT_1,
Studierendenantragstatus_model::STATUS_REQUESTSENT_2
],
$dateDeadline,
$digi_start
);
if(isError($result))
{
$this->logError(getError($result));
}
else
{
$prestudents = getData($result) ?: [];
$count = 0;
$prestudents = $this->prestudentsGetUnique($prestudents);
foreach ($prestudents as $prestudent)
{
$result = $this->StudierendenantragstatusModel->insert([
'studierendenantrag_id' => $prestudent->studierendenantrag_id,
'studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_DEREGISTERED,
'insertvon' => 'AntragJob'
]);
if (isError($result)) {
$this->logError(getError($result));
} else {
$deregisterStatus = getData($result);
$result = $this->antraglib->pauseAntrag(
$prestudent->studierendenantrag_id,
Studierendenantragstatus_model::INSERTVON_DEREGISTERED
);
if (isError($result))
$this->logError(getError($result));
$result = $this->prestudentlib->setAbbrecher($prestudent->prestudent_id, '', $insertvon);
if (isError($result)) {
$this->StudierendenantragstatusModel->delete($deregisterStatus);
$this->logError(getError($result));
} else {
$count++;
$datum_kp = new DateTime($prestudent->datum);
$dataMail = array(
'name'=> trim($prestudent->vorname . ' '. $prestudent->nachname),
'vorname' => $prestudent->vorname,
'nachname' => $prestudent->nachname,
'pers_kz'=> $prestudent->matrikelnr,
'stg' => $prestudent->bezeichnung,
'lvbezeichnung' => $prestudent->lvbezeichnung,
'datum_kp' => $datum_kp->format('d.m.Y'),
'studiensemester'=> $prestudent->studiensemester_kurzbz,
'Orgform'=> $prestudent->orgform,
'prestudent_id' => $prestudent->prestudent_id,
'fristablauf' => $dateDeadline->format('d.m.Y')
);
$email = $this->StudentModel->getEmailFH($this->StudentModel->getUID($prestudent->prestudent_id));
// Mail to Student
if (!sendSanchoMail('Sancho_Mail_Antrag_W_DL_Stud', $dataMail, $email, 'Wiederholung: Frist abgelaufen')) {
$this->logWarning("Failed to send Notification to " . $email);
}
$result = $this->StudiengangModel->load($prestudent->studiengang_kz);
if (!hasData($result)) {
$this->logWarning('No Studiengang found');
continue;
}
$studiengang = current(getData($result));
$email = $studiengang->email;
// Mail to Assistenz
if (!sendSanchoMail('Sancho_Mail_Antrag_W_DL_Assist', $dataMail, $email, 'Wiederholung: Frist abgelaufen')) {
$this->logWarning("Failed to send Notification to " . $email);
}
}
}
}
$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');
$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));
$this->StudierendenantragModel->addSelect('tbl_studierendenantrag.studierendenantrag_id');
$this->StudierendenantragModel->addSelect('prestudent_id');
$this->StudierendenantragModel->addSelect('studiensemester_kurzbz');
$this->StudierendenantragModel->addSelect('s.insertamum');
$this->StudierendenantragModel->addSelect('s.insertvon');
$this->StudierendenantragModel->db->where_in(
'public.get_rolle_prestudent(prestudent_id, studiensemester_kurzbz)',
$this->config->item('antrag_prestudentstatus_whitelist')
);
$result = $this->StudierendenantragModel->getWithLastStatusWhere([
'typ' => Studierendenantrag_model::TYP_ABMELDUNG_STGL,
'studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_APPROVED,
's.insertamum <=' => $dateDeadline->format('c')
]);
if(isError($result))
{
$this->logError(getError($result));
}
else
{
$antraege = getData($result) ?: [];
$count = 0;
foreach ($antraege as $antrag)
{
$result = $this->StudierendenantragstatusModel->insert([
'studierendenantrag_id' => $antrag->studierendenantrag_id,
'studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_DEREGISTERED,
'insertvon' => 'AntragJob'
]);
if (isError($result))
$this->logError(getError($result));
else {
$deregisterStatus = getData($result);
$result = $this->antraglib->pauseAntrag($antrag->studierendenantrag_id, Studierendenantragstatus_model::INSERTVON_DEREGISTERED);
if (isError($result))
$this->logError(getError($result));
$result = $this->prestudentlib->setAbbrecher(
$antrag->prestudent_id,
$antrag->studiensemester_kurzbz,
'AntragJob',
'abbrecherStgl',
$antrag->insertamum,
null,
$antrag->insertvon ?: $insertvon
);
if (isError($result)) {
$this->StudierendenantragstatusModel->delete($deregisterStatus);
$this->logError(getError($result));
} else {
$count++;
$result = $this->PrestudentModel->load($antrag->prestudent_id);
if(!hasData($result)) {
$this->logWarning('No Prestudent found');
continue;
}
$prestudent = current(getData($result));
$result = $this->StudiengangModel->load($prestudent->studiengang_kz);
if(!hasData($result)) {
$this->logWarning('No Studiengang found');
continue;
}
$studiengang = current(getData($result));
$result = $this->PersonModel->loadPrestudent($antrag->prestudent_id);
if(!hasData($result))
{
$this->logWarning('No Person found');
continue;
}
$person = current(getData($result));
$email = $studiengang->email;
$dataMail = array(
'prestudent' => $antrag->prestudent_id,
'studiensemester' => $antrag->studiensemester_kurzbz,
'name' => trim($person->vorname . ' '. $person->nachname),
);
if(!sendSanchoMail('Sancho_Mail_Antrag_A_Assist', $dataMail, $email, 'Einspruchsfrist abgelaufen'))
{
$this->logWarning("Failed to send Notification to " . $email);
}
}
}
}
$this->logInfo($count . "/" . count($antraege) . " 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');
$digi_start = $this->config->item('digitalization_start');
if ($digi_start) {
try {
$digi_start = new DateTime($digi_start);
} catch(Exception $e) {
}
}
if ($modifier_deadline) {
$dateDeadline = new DateTime();
$dateDeadline->sub(DateInterval::createFromDateString($modifier_deadline));
if ($digi_start)
$dateDeadline = max($digi_start, $dateDeadline);
} else {
$dateDeadline = $digi_start ?: null;
}
//first request
if ($modifier_request_1) {
$dateStichtag = new DateTime();
$dateStichtag->sub(DateInterval::createFromDateString($modifier_request_1));
if (!$dateDeadline || $dateStichtag > $dateDeadline)
$this->sendReminder(
'Request1',
null,
Studierendenantragstatus_model::STATUS_REQUESTSENT_1,
$dateDeadline,
$dateStichtag,
$modifier_deadline,
'Aufforderung: Bekanntgabe Wiederholung'
);
} else
$this->logError('Config "wiederholung_job_request_1_date_modifier" nicht gesetzt');
//second request
if ($modifier_request_2) {
$dateStichtag = new DateTime();
$dateStichtag->sub(DateInterval::createFromDateString($modifier_request_2));
if (!$dateDeadline || $dateStichtag > $dateDeadline)
$this->sendReminder(
'Request2',
Studierendenantragstatus_model::STATUS_REQUESTSENT_1,
Studierendenantragstatus_model::STATUS_REQUESTSENT_2,
$dateDeadline,
$dateStichtag,
$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_stichtag, $modifier_deadline, $subject)
{
$this->logInfo('Start Job sendAufforderungWiederholer ' . $name);
$result = $this->PruefungModel->getAllPrestudentsWhereCommitteeExamFailed($status_from, $date_stichtag, $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);
$urlCIS = CIS_ROOT . 'index.ci.php/lehre/Studierendenantrag/wiederholung/' . $prestudent->prestudent_id;
$email = $this->StudentModel->getEmailFH($this->StudentModel->getUID($prestudent->prestudent_id));
$fristende = new DateTime($prestudent->datum);
$fristende->add(DateInterval::createFromDateString($modifier_deadline));
$datum_kp = new DateTime($prestudent->datum);
$result = $this->StudiensemesterModel->getNextFrom($prestudent->studiensemester_kurzbz);
$next_sem = "";
$sem_after_next_sem = "";
if (hasData($result)) {
$next_sem = current(getData($result))->studiensemester_kurzbz;
$result = $this->StudiensemesterModel->getNextFrom($next_sem);
if (hasData($result)) {
$sem_after_next_sem = current(getData($result))->studiensemester_kurzbz;
}
}
$dataMail = array(
'name'=> trim($prestudent->vorname . ' '. $prestudent->nachname),
'vorname' => $prestudent->vorname,
'nachname' => $prestudent->nachname,
'pers_kz'=> $prestudent->matrikelnr,
'stg' => $prestudent->bezeichnung,
'lvbezeichnung' => $prestudent->lvbezeichnung,
'datum_kp' => $datum_kp->format('d.m.Y'),
'studiensemester'=> $prestudent->studiensemester_kurzbz,
'Orgform'=> $prestudent->orgform,
'prestudent_id' => $prestudent->prestudent_id,
'url' => $url,
'urlCIS' => $urlCIS,
'fristablauf' => $fristende->format('d.m.Y'),
'pre_wiederholer_sem' => $next_sem,
'wiederholer_sem' => $sem_after_next_sem,
'sem' => $prestudent->ausbildungssemester
);
// NOTE(chris): Sancho mail
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);
}
}
-165
View File
@@ -1,165 +0,0 @@
<?php
if (!defined('BASEPATH')) exit('No direct script access allowed');
require_once('schedulers/ESIScheduler.php');
/**
* Controller for initialising generateESI job
*/
class ESIJob extends JQW_Controller
{
const ESI_PREFIX = 'urn:schac:personalUniqueCode:int:esi:at:';
const INSERT_VON = 'generateEsiJob';
/**
* Controller initialization
*/
public function __construct()
{
parent::__construct();
// load models
$this->load->model('person/Person_model', 'PersonModel');
$this->load->model('person/Kennzeichen_model', 'KennzeichenModel');
}
//------------------------------------------------------------------------------------------------------------------
// Public methods
/**
* Initialises generateESI job, handles job queue, logs infos/errors
*/
public function generateESI()
{
//$jobType = 'DVUHSendPruefungsaktivitaeten';
$this->logInfo(ESIScheduler::JOB_TYPE_GENERATE_ESI.' job start');
// Gets the latest jobs
$lastJobs = $this->getLastJobs(ESIScheduler::JOB_TYPE_GENERATE_ESI);
if (isError($lastJobs))
{
$this->logError(getCode($lastJobs).': '.getError($lastJobs), ESIScheduler::JOB_TYPE_GENERATE_ESI);
}
else
{
$this->updateJobs(
getData($lastJobs), // Jobs to be updated
array(JobsQueueLib::PROPERTY_START_TIME), // Job properties to be updated
array(date('Y-m-d H:i:s')) // Job properties new values
);
$person_arr = $this->_getInputObjArray(getData($lastJobs));
foreach ($person_arr as $persobj)
{
if (!isset($persobj->person_id))
$this->logError("Error when generating ESI: invalid parameters");
else
{
$person_id = $persobj->person_id;
// check if there already is an active ESI
$this->KennzeichenModel->addSelect('1');
$activeKennzeichenRes = $this->KennzeichenModel->loadWhere(
array('person_id' => $person_id, 'kennzeichentyp_kurzbz' => ESIScheduler::KENNZEICHENTYP_KURZBZ, 'aktiv' => true)
);
if (hasData($activeKennzeichenRes))
{
$this->logError("Active ESI for person Id $person_id already exists");
continue;
}
// get Matrikelnr for person for which ESI should be generated
$this->PersonModel->addSelect('matr_nr');
$personRes = $this->PersonModel->load($person_id);
if (!hasData($personRes))
{
$this->logError("Person with Id $person_id not found");
continue;
}
$matr_nr = getData($personRes)[0]->matr_nr;
if (isEmptyString($matr_nr))
{
$this->logError("Matrikelnummer for person with Id $person_id is empty");
continue;
}
$esi = self::ESI_PREFIX.$matr_nr;
// check if ESI was already used
$this->KennzeichenModel->addSelect('1');
$existingKennzeichenRes = $this->KennzeichenModel->loadWhere(
array('person_id' => $person_id, 'kennzeichentyp_kurzbz' => ESIScheduler::KENNZEICHENTYP_KURZBZ, 'inhalt' => $esi)
);
if (hasData($existingKennzeichenRes))
{
$this->logError("ESI $esi for person Id $person_id already exists");
continue;
}
// if everything ok, save the esi for the person
$saveEsiResult = $this->KennzeichenModel->insert(
array(
'person_id' => $person_id,
'kennzeichentyp_kurzbz' => ESIScheduler::KENNZEICHENTYP_KURZBZ,
'inhalt' => $esi,
'aktiv' => true,
'insertvon' => self::INSERT_VON
)
);
if (isError($saveEsiResult))
{
$this->logError("Error when sending ESI, person Id $person_id ".getError($saveEsiResult));
}
}
}
// Update jobs properties values
$this->updateJobs(
getData($lastJobs), // Jobs to be updated
array(JobsQueueLib::PROPERTY_STATUS, JobsQueueLib::PROPERTY_END_TIME), // Job properties to be updated
array(JobsQueueLib::STATUS_DONE, date('Y-m-d H:i:s')) // Job properties new values
);
if (hasData($lastJobs)) $this->updateJobsQueue(ESIScheduler::JOB_TYPE_GENERATE_ESI, getData($lastJobs));
}
$this->logInfo(ESIScheduler::JOB_TYPE_GENERATE_ESI.' job stop');
}
// --------------------------------------------------------------------------------------------
// Private methods
/**
* Extracts input data from jobs.
* @param $jobs
* @return array with jobinput
*/
private function _getInputObjArray($jobs)
{
$mergedUsersArray = array();
if (count($jobs) == 0) return $mergedUsersArray;
foreach ($jobs as $job)
{
$decodedInput = json_decode($job->input);
if ($decodedInput != null)
{
foreach ($decodedInput as $el)
{
$mergedUsersArray[] = $el;
}
}
}
return $mergedUsersArray;
}
}
@@ -44,7 +44,6 @@ class IssueResolver extends IssueResolver_Controller
'CORE_STUDENTSTATUS_0012' => 'CORE_STUDENTSTATUS_0012',
'CORE_STUDENTSTATUS_0013' => 'CORE_STUDENTSTATUS_0013',
'CORE_STUDENTSTATUS_0014' => 'CORE_STUDENTSTATUS_0014',
'CORE_STUDENTSTATUS_0015' => 'CORE_STUDENTSTATUS_0015',
'CORE_PERSON_0001' => 'CORE_PERSON_0001',
'CORE_PERSON_0002' => 'CORE_PERSON_0002',
'CORE_PERSON_0003' => 'CORE_PERSON_0003',
@@ -1,29 +1,16 @@
<?php
/**
* Job for producing core Plausicheck issues
* Job for producing Plausicheck issues
*/
class PlausiIssueProducer extends PlausiIssueProducer_Controller
class PlausiIssueProducer extends JOB_Controller
{
private $_currentStudiensemester;
protected $_app = 'core';
public function __construct()
{
parent::__construct();
$this->load->library('issues/PlausicheckDefinitionLib');
// load models
$this->load->model('organisation/studiensemester_model', 'StudiensemesterModel');
// get current Studiensemester
$studiensemesterRes = $this->StudiensemesterModel->getAkt();
if (hasData($studiensemesterRes)) $this->_currentStudiensemester = getData($studiensemesterRes)[0]->studiensemester_kurzbz;
// set fehler which can be produced by the job
// structure: fehler_kurzbz => class (library) name for resolving
$this->_fehlerLibMappings = $this->plausicheckdefinitionlib->getFehlerLibMappings();
$this->load->library('issues/PlausicheckProducerLib');
$this->load->library('IssuesLib');
}
/**
@@ -33,10 +20,43 @@ class PlausiIssueProducer extends PlausiIssueProducer_Controller
*/
public function run($studiensemester_kurzbz = null, $studiengang_kz = null)
{
// get Studiensemester
if (isEmptyString($studiensemester_kurzbz)) $studiensemester_kurzbz = $this->_currentStudiensemester;
$fehlerKurzbz = $this->plausicheckproducerlib->getFehlerKurzbz();
// producing issues for semester and optionally Studiengang
$this->producePlausicheckIssues(array('studiensemester_kurzbz' => $studiensemester_kurzbz, 'studiengang_kz' => $studiengang_kz));
$this->logInfo("Plausicheck issue producer job started");
// get the data returned by Plausicheck
foreach ($fehlerKurzbz as $fehler_kurzbz)
{
// execute the check
$this->logInfo("Checking " . $fehler_kurzbz . "...");
$plausicheckRes = $this->plausicheckproducerlib->producePlausicheckIssue($fehler_kurzbz, $studiensemester_kurzbz, $studiengang_kz);
if (isError($plausicheckRes)) $this->logError(getError($plausicheckRes));
if (hasData($plausicheckRes))
{
$plausicheckData = getData($plausicheckRes);
foreach ($plausicheckData as $plausiData)
{
// get the data needed for issue production
$person_id = isset($plausiData['person_id']) ? $plausiData['person_id'] : null;
$oe_kurzbz = isset($plausiData['oe_kurzbz']) ? $plausiData['oe_kurzbz'] : null;
$fehlertext_params = isset($plausiData['fehlertext_params']) ? $plausiData['fehlertext_params'] : null;
$resolution_params = isset($plausiData['resolution_params']) ? $plausiData['resolution_params'] : null;
// write the issue
$addIssueRes = $this->issueslib->addFhcIssue($fehler_kurzbz, $person_id, $oe_kurzbz, $fehlertext_params, $resolution_params);
// log if error, or log info if inserted new issue
if (isError($addIssueRes))
$this->logError(getError($addIssueRes));
elseif (hasData($addIssueRes) && is_integer(getData($addIssueRes)))
$this->logInfo("Plausicheck issue " . $fehler_kurzbz . " successfully produced, person_id: " . $person_id);
}
}
}
$this->logInfo("Plausicheck issue producer job stopped");
}
}
@@ -3,9 +3,6 @@ if (!defined('BASEPATH')) exit('No direct script access allowed');
class ReihungstestJob extends JOB_Controller
{
const LAST_DAYS_PRESTUDENTSTATUS = 5;
/**
* Constructor
*/
@@ -467,7 +464,7 @@ class ReihungstestJob extends JOB_Controller
$this->PrestudentstatusModel->addJoin('public.tbl_person', 'person_id');
$yesterdays_applicants_arr = $this->PrestudentstatusModel->loadWhere('
status_kurzbz IN (\'Interessent\', \'Bewerber\') AND
status_kurzbz = \'Interessent\' AND
typ = \'b\' AND
bestaetigtam = current_date - 1
');
@@ -730,27 +727,33 @@ class ReihungstestJob extends JOB_Controller
tbl_reihungstest.reihungstest_id,
tbl_studienplan.studienplan_id,
tbl_reihungstest.studiensemester_kurzbz,
tbl_studienordnung.studiengang_kz,
tbl_studienplan.orgform_kurzbz
tbl_studienordnung.studiengang_kz
FROM
public.tbl_reihungstest
JOIN public.tbl_rt_studienplan ON(tbl_rt_studienplan.reihungstest_id=tbl_reihungstest.reihungstest_id)
JOIN lehre.tbl_studienplan USING(studienplan_id)
JOIN lehre.tbl_studienordnung USING(studienordnung_id)
JOIN public.tbl_rt_studienplan ON(tbl_rt_studienplan.reihungstest_id=tbl_reihungstest.reihungstest_id)
JOIN lehre.tbl_studienplan USING(studienplan_id)
JOIN lehre.tbl_studienordnung USING(studienordnung_id)
WHERE
EXISTS (
SELECT studienplan_id
FROM lehre.tbl_studienordnung sordnung
JOIN lehre.tbl_studienplan USING (studienordnung_id)
JOIN lehre.tbl_studienplan_semester USING (studienplan_id)
WHERE sordnung.studiengang_kz = tbl_studienordnung.studiengang_kz
AND tbl_studienplan_semester.studiensemester_kurzbz = tbl_reihungstest.studiensemester_kurzbz
AND tbl_studienplan.studienplan_id NOT IN
(
SELECT studienplan_id FROM tbl_rt_studienplan WHERE reihungstest_id = tbl_reihungstest.reihungstest_id
)
NOT EXISTS(
SELECT 1 FROM lehre.tbl_studienplan_semester
WHERE studienplan_id=tbl_rt_studienplan.studienplan_id
AND tbl_studienplan_semester.studiensemester_kurzbz=tbl_reihungstest.studiensemester_kurzbz
)
AND tbl_reihungstest.datum >= now()";
AND tbl_reihungstest.datum >= now()
AND NOT EXISTS(
SELECT
1
FROM
public.tbl_rt_studienplan rtstp
JOIN lehre.tbl_studienplan stp USING(studienplan_id)
JOIN lehre.tbl_studienordnung sto USING(studienordnung_id)
JOIN lehre.tbl_studienplan_semester stpsem USING(studienplan_id)
WHERE
sto.studiengang_kz=tbl_studienordnung.studiengang_kz
AND rtstp.reihungstest_id=tbl_reihungstest.reihungstest_id
AND stpsem.studiensemester_kurzbz=tbl_reihungstest.studiensemester_kurzbz
)
";
$db = new DB_Model();
$result_rt = $db->execReadOnlyQuery($qry);
@@ -760,9 +763,7 @@ class ReihungstestJob extends JOB_Controller
// find an active studyplan for the same degree program with is valid in this semester
$result_stpl = $this->StudienplanModel->getStudienplaeneBySemester(
$row_rt->studiengang_kz,
$row_rt->studiensemester_kurzbz,
null,
$row_rt->orgform_kurzbz
$row_rt->studiensemester_kurzbz
);
if (hasData($result_stpl)) {
@@ -825,7 +826,7 @@ class ReihungstestJob extends JOB_Controller
AND tbl_studiengang.typ IN ('b', 'm')
)
SELECT * FROM prst
WHERE prestudenstatus_datum >= (SELECT CURRENT_DATE - ". self::LAST_DAYS_PRESTUDENTSTATUS .")
WHERE prestudenstatus_datum >= (SELECT CURRENT_DATE - 1)
AND (studiengang_typ = 'b' OR (studiengang_typ = 'm' AND EXISTS (SELECT 1 /* Master Studiengänge berücksichtigen wenn auch Bachelor im gleichen Semester */
FROM prst prstb
WHERE studiengang_typ = 'b'
@@ -867,8 +868,7 @@ class ReihungstestJob extends JOB_Controller
tbl_person.nachname,
tbl_person.vorname,
tbl_prestudent.*,
tbl_studiengang.typ AS studiengang_typ,
tbl_prestudentstatus.datum
tbl_studiengang.typ AS studiengang_typ
FROM PUBLIC.tbl_person
JOIN PUBLIC.tbl_prestudent USING (person_id)
JOIN PUBLIC.tbl_prestudentstatus USING (prestudent_id)
@@ -901,7 +901,7 @@ class ReihungstestJob extends JOB_Controller
$mailArray[$rowNiedrPrios->studiengang_kz][$rowNiedrPrios->orgform_kurzbz]['AufnahmeHoeherePrio'][]
= $rowNiedrPrios->nachname.' '.$rowNiedrPrios->vorname.' ('.$rowNiedrPrios->prestudent_id.')';
}
elseif ($rowNiedrPrios->laststatus == 'Bewerber' && $row_ps->prestudenstatus_datum > $rowNiedrPrios->datum)
elseif ($rowNiedrPrios->laststatus == 'Bewerber')
{
// Abgewiesenen-Status mit Statusgrund "Aufnahme anderer Studiengang" (ID 5) setzen
$lastStatus = $this->PrestudentstatusModel->getLastStatus($rowNiedrPrios->prestudent_id);
@@ -927,7 +927,7 @@ class ReihungstestJob extends JOB_Controller
= $rowNiedrPrios->nachname.' '.$rowNiedrPrios->vorname.' ('.$rowNiedrPrios->prestudent_id.')';
}
}
elseif ($rowNiedrPrios->laststatus == 'Wartender' && $row_ps->prestudenstatus_datum > $rowNiedrPrios->datum)
elseif ($rowNiedrPrios->laststatus == 'Wartender')
{
// Abgewiesenen-Status mit Statusgrund "Aufnahme anderer Studiengang" (ID 5) setzen
// Mail zur Info an Assistenz schicken
@@ -1,108 +0,0 @@
<?php
if (!defined('BASEPATH')) exit('No direct script access allowed');
/**
* Scheduler for generating ESI (European Student Identifier)
*/
class ESIScheduler extends JQW_Controller
{
const JOB_TYPE_GENERATE_ESI = 'generateESI';
const KENNZEICHENTYP_KURZBZ = 'esi';
private $_active_status_kurzbz = array('Student', 'Diplomand');
/**
* Controller initialization
*/
public function __construct()
{
parent::__construct();
$this->load->model('organisation/Studiensemester_model', 'StudiensemesterModel');
}
//------------------------------------------------------------------------------------------------------------------
// Public methods
/**
* Creates jobs queue entries for generateESI job.
* @param string $studiensemester_kurzbz semester for which ESIs should be generated
*/
public function generateESI($studiensemester_kurzbz = null)
{
// if no semester given, get current studiensemester
if (!isset($studiensemester_kurzbz))
{
$semRes = $this->StudiensemesterModel->getAkt();
if (hasData($semRes))
{
$studiensemester_kurzbz = getData($semRes)[0]->studiensemester_kurzbz;
}
}
if (isset($studiensemester_kurzbz))
{
$this->logInfo('Start job queue scheduler '.self::JOB_TYPE_GENERATE_ESI);
$qry = "
SELECT
DISTINCT person_id
FROM
public.tbl_person pers
JOIN public.tbl_prestudent ps USING (person_id)
JOIN public.tbl_prestudentstatus pss USING (prestudent_id)
WHERE
pss.studiensemester_kurzbz = ?
AND pers.matr_nr IS NOT NULL
AND pss.status_kurzbz IN ?
AND NOT EXISTS ( -- has no ESI yet
SELECT 1
FROM
public.tbl_kennzeichen
WHERE
person_id = pers.person_id
AND kennzeichentyp_kurzbz = ?
AND aktiv
)
AND NOT EXISTS ( -- making sure it's not an incoming
SELECT 1
FROM
public.tbl_prestudentstatus
WHERE
prestudent_id = ps.prestudent_id
AND status_kurzbz = 'Incoming'
)";
$db = new DB_Model();
$jobInputResult = $db->execReadOnlyQuery($qry, array($studiensemester_kurzbz, $this->_active_status_kurzbz, self::KENNZEICHENTYP_KURZBZ));
// If an error occured then log it
if (isError($jobInputResult))
{
$this->logError(getError($jobInputResult));
}
elseif (hasData($jobInputResult)) // if persons found
{
// Add the new job to the jobs queue
$addNewJobResult = $this->addNewJobsToQueue(
self::JOB_TYPE_GENERATE_ESI, // job type
$this->generateJobs( // gnerate the structure of the new job
JobsQueueLib::STATUS_NEW,
json_encode(getData($jobInputResult))
)
);
// If error occurred return it
if (isError($addNewJobResult)) $this->logError(getError($addNewJobResult));
}
}
else
{
$this->logError('Error when getting Studiensemester');
}
$this->logInfo('End job queue scheduler '.self::JOB_TYPE_GENERATE_ESI);
}
}
@@ -1,114 +0,0 @@
<?php
if (!defined("BASEPATH")) exit("No direct script access allowed");
use vertragsbestandteil\VertragsbestandteilFactory;
/**
* Description of VertragsbestandteilTest
*
* @author bambi
*/
class VertragsbestandteilTest extends JOB_Controller
{
public function __construct()
{
parent::__construct();
$this->load->library('vertragsbestandteil/VertragsbestandteilLib',
null, 'VertragsbestandteilLib');
$this->load->library('vertragsbestandteil/GehaltsbestandteilLib',
null, 'GehaltsbestandteilLib');
}
public function testFetch()
{
$dienstverhaeltnis_id = 1;
$stichtag = null;
foreach($this->VertragsbestandteilLib->fetchVertragsbestandteile(
$dienstverhaeltnis_id, $stichtag) as $vertragsbestandteil)
{
//print_r($vertragsbestandteil);
echo $vertragsbestandteil . "\n";
}
}
public function testUpdate()
{
$now = new DateTime();
$data = new stdClass();
$data->vertragsbestandteil_id = 32;
$data->von = '2022-12-05';
$data->wochenstunden = 45.0;
$data->vertragsbestandteiltyp_kurzbz = VertragsbestandteilFactory::VERTRAGSBESTANDTEIL_STUNDEN;
$vb = VertragsbestandteilFactory::getVertragsbestandteil($data);
try
{
$this->VertragsbestandteilLib->storeVertragsbestandteil($vb);
echo "Update successful.\n";
}
catch( Exception $ex )
{
echo "Update failed.\n";
}
}
public function testInsert()
{
$now = new DateTime();
$data = new stdClass();
$data->dienstverhaeltnis_id = 1;
$data->von = '2022-12-01';
$data->insertamum = $now->format(DateTime::ATOM);
$data->insertvon = 'ma0080';
$data->vertragsbestandteiltyp_kurzbz = VertragsbestandteilFactory::VERTRAGSBESTANDTEIL_FUNKTION;
$data->benutzerfunktion_id = 112667;
$data->anmerkung = 'test funkton';
$data->kuendigungsrelevant = false;
$vb = VertragsbestandteilFactory::getVertragsbestandteil($data);
try
{
$this->VertragsbestandteilLib->storeVertragsbestandteil($vb);
echo "Insert successful.\n";
}
catch( Exception $ex )
{
echo "Insert failed.\n";
}
}
public function testGehaltsbestandteilInsert()
{
$data = new stdClass();
$data->gehaltsbestandteil_id = 2;
/*
$data->dienstverhaeltnis_id = 39;
$data->vertragsbestandteil_id = 123;
$data->gehaltstyp_kurzbz = 'zulage';
$data->von = '2023-04-01';
$data->bis = '2023-08-31';
$data->anmerkung = 'test anmerkung';
$data->grundbetrag = 100;
$data->betrag_valorisiert = 100;
$data->valorisierung = true;
*/
$data->auszahlungen = 12;
$gb = new \vertragsbestandteil\Gehaltsbestandteil();
$gb->hydrateByStdClass($data);
print_r($gb->toStdClass());
$this->GehaltsbestandteilLib->storeGehaltsbestandteil($gb);
}
}
@@ -1,82 +0,0 @@
<?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));
}
}
@@ -1,48 +0,0 @@
<?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)
{
$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)
]);
}
}
@@ -1,188 +0,0 @@
<?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->getPrestudentWiederholungsBerechtigt($antrag->prestudent_id);
if (getData($result) == 1)
$prestudentenArr[$antrag->prestudent_id]['allowedNewTypes'][] = 'Wiederholung';
$result = $this->antraglib->getPrestudentUnterbrechungsBerechtigt($antrag->prestudent_id);
if (getData($result) == 1)
$prestudentenArr[$antrag->prestudent_id]['allowedNewTypes'][] = 'Unterbrechung';
$result = $this->antraglib->getPrestudentAbmeldeBerechtigt($antrag->prestudent_id);
if (getData($result) == 1)
$prestudentenArr[$antrag->prestudent_id]['allowedNewTypes'][] = 'Abmeldung';
}
if ($antrag->studierendenantrag_id == null)
continue;
if ($antrag->typ == Studierendenantrag_model::TYP_ABMELDUNG_STGL && (!$antrag->isapproved))
continue;
$prestudentenArr[$antrag->prestudent_id]['antraege'][] = $antrag;
}
$this->load->view('lehre/Antrag/Student/List', [
'antraege' => $prestudentenArr
]);
}
public function leitung()
{
$stgL = $this->permissionlib->getSTG_isEntitledFor('student/antragfreigabe') ?: [];
$stgA = $this->permissionlib->getSTG_isEntitledFor('student/studierendenantrag') ?: [];
$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 abmeldungstgl($prestudent_id, $studierendenantrag_id = null)
{
$this->load->view('lehre/Antrag/Create', [
'prestudent_id' => $prestudent_id,
'studierendenantrag_id' => $studierendenantrag_id,
'antrag_type' => 'AbmeldungStgl'
]);
}
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;
}
}
@@ -1,187 +0,0 @@
<?php
if (! defined('BASEPATH')) exit('No direct script access allowed');
class AdminAnrechnung extends Auth_Controller
{
public function __construct()
{
// Set required permissions
parent::__construct(
array(
'index' => 'lehre/anrechnungszeitfenster:rw',
'save' => 'lehre/anrechnungszeitfenster:rw',
'edit' => 'lehre/anrechnungszeitfenster:rw',
'delete' => 'lehre/anrechnungszeitfenster:rw'
)
);
// Load models
$this->load->model('education/Anrechnung_model', 'AnrechnungModel');
$this->load->model('education/Anrechnungszeitraum_model', 'AnrechnungszeitraumModel');
$this->load->model('organisation/Studiensemester_model', 'StudiensemesterModel');
// Load libraries
$this->load->library('WidgetLib');
$this->load->library('PermissionLib');
$this->load->library('AnrechnungLib');
// Load language phrases
$this->loadPhrases(
array(
'global',
'ui',
'lehre',
'anrechnung',
'table'
)
);
$this->_setAuthUID();
$this->setControllerId();
}
public function index()
{
// Set nearest Studiensemester as default
$result = $this->StudiensemesterModel->getNearest();
$studiensemester_kurzbz = hasData($result) ? getData($result)[0]->studiensemester_kurzbz : '';
// Get existing Anrechnungszeitraeume
$this->AnrechnungszeitraumModel->addOrder('anrechnungszeitraum_id', 'DESC');
$result = $this->AnrechnungszeitraumModel->load();
$anrechnungszeitraum_arr = hasData($result) ? getData($result) : array();
$viewData = array(
'studiensemester_kurzbz' => $studiensemester_kurzbz,
'anrechnungszeitraum_arr' => $anrechnungszeitraum_arr
);
$this->load->view('lehre/anrechnung/adminAnrechnung.php', $viewData);
}
/**
* Save new Anrechnungszeitraum.
*/
public function save()
{
$this->_validate($this->input->post());
$studiensemester_kurzbz = $this->input->post('studiensemester_kurzbz');
$anrechnungstart = $this->input->post('anrechnungstart');
$anrechnungende = $this->input->post('anrechnungende');
$result = $this->AnrechnungszeitraumModel->insertAzr($studiensemester_kurzbz, $anrechnungstart, $anrechnungende);
if (isError($result))
{
$this->terminateWithJsonError(getError($result));
}
if (hasData($result))
{
$this->outputJsonSuccess(array('anrechnungszeitraum_id' => getData($result)));
}
}
/**
* Edit Anrechnungszeitraum.
*/
public function edit()
{
$this->_validate($this->input->post());
$anrechnungszeitraum_id = $this->input->post('anrechnungszeitraum_id');
$studiensemester_kurzbz = $this->input->post('studiensemester_kurzbz');
$anrechnungstart = $this->input->post('anrechnungstart');
$anrechnungende = $this->input->post('anrechnungende');
$result = $this->AnrechnungszeitraumModel->updateAzr(
$anrechnungszeitraum_id,
$studiensemester_kurzbz,
$anrechnungstart,
$anrechnungende
);
if (isError($result))
{
$this->terminateWithJsonError(getError($result));
}
if (hasData($result))
{
$this->outputJsonSuccess(array('anrechnungszeitraum_id' => getData($result)));
}
}
/**
* Delete Anrechnungszeitraum.
*/
public function delete()
{
$anrechnungszeitraum_id = $this->input->post('anrechnungszeitraum_id');
$result = $this->AnrechnungszeitraumModel->deleteAzr($anrechnungszeitraum_id);
if (isError($result))
{
$this->terminateWithJsonError(getError($result));
}
if (hasData($result))
{
$this->outputJsonSuccess(array('anrechnungszeitraum_id' => getData($result)));
}
}
/**
* Validates post parameters.
*
* @param $post
*/
private function _validate($post)
{
$studiensemester_kurzbz = $post['studiensemester_kurzbz'];
$anrechnungstart = $post['anrechnungstart'];
$anrechnungende = $post['anrechnungende'];
if (isEmptyString($studiensemester_kurzbz)
|| isEmptyString($anrechnungstart)
|| isEmptyString($anrechnungende))
{
$this->terminateWithJsonError($this->p->t('ui', 'errorFelderFehlen'));
}
if ($anrechnungstart > $anrechnungende)
{
$this->terminateWithJsonError($this->p->t('ui', 'errorStartdatumNachEndedatum'));
}
$result = $this->StudiensemesterModel->load($studiensemester_kurzbz);
$studiensemester = getData($result)[0];
if ($anrechnungstart < $studiensemester->start || $anrechnungstart > $studiensemester->ende)
{
$this->terminateWithJsonError($this->p->t('ui', 'errorStartdatumNichtInStudiensemester'));
}
if ($anrechnungende < $studiensemester->start || $anrechnungende > $studiensemester->ende)
{
$this->terminateWithJsonError($this->p->t('ui', 'errorEndedatumNichtInStudiensemester'));
}
}
/**
* Retrieve the UID of the logged user and checks if it is valid
*/
private function _setAuthUID()
{
$this->_uid = getAuthUID();
if (!$this->_uid) show_error('User authentification failed');
}
}
@@ -33,9 +33,6 @@ class approveAnrechnungDetail extends Auth_Controller
)
);
//Load configs
$this->load->config('anrechnung');
// Load models
$this->load->model('education/Anrechnung_model', 'AnrechnungModel');
$this->load->model('education/Anrechnungstatus_model', 'AnrechnungstatusModel');
@@ -93,8 +90,7 @@ class approveAnrechnungDetail extends Auth_Controller
$antragData = $this->anrechnunglib->getAntragData(
$anrechnungData->prestudent_id,
$anrechnungData->studiensemester_kurzbz,
$anrechnungData->lehrveranstaltung_id,
$anrechnungData->anrechnung_id
$anrechnungData->lehrveranstaltung_id
);
// Get Empfehlung data
@@ -213,64 +209,71 @@ class approveAnrechnungDetail extends Auth_Controller
*/
public function requestRecommendation()
{
$anrechnung_id = $this->input->post('anrechnung_id');
$data = $this->input->post('data');
if(isEmptyString($anrechnung_id))
if(isEmptyArray($data))
{
return $this->outputJsonError('Fehler beim Übertragen der Daten.');
}
$retval = array();
// Check if Anrechnungs-LV has lector
if (!$this->anrechnunglib->LVhasLector($anrechnung_id))
{
$this->terminateWithJsonError('LV has no lector');
}
$counter = 0;
// Get Fachbereichsleitung or LV Leitung.
if($this->config->item('fbl') === TRUE)
{
$result = $this->anrechnunglib->getLeitungOfLvOe($anrechnung_id);
}
else
{
// If LV Leitung is not present, gets all LV lectors.
$result = $this->anrechnunglib->getLectors($anrechnung_id);
}
foreach ($data as $item)
{
// Check if Anrechnungs-LV has lector
if (!$this->anrechnunglib->LVhasLector($item['anrechnung_id']))
{
// Count up LV with no lector
$counter++;
$empfehlungsanfrage_an = !isEmptyArray($result) ? implode(', ', array_column($result, 'fullname')) : '';
// Break, if LV has no lector
break;
}
// Request Recommendation
if ($this->anrechnunglib->requestRecommendation($anrechnung_id))
{
$retval[]= array(
'anrechnung_id' => $anrechnung_id,
'status_kurzbz' => self::ANRECHNUNGSTATUS_PROGRESSED_BY_LEKTOR,
'status_bezeichnung' => $this->anrechnunglib->getStatusbezeichnung(self::ANRECHNUNGSTATUS_PROGRESSED_BY_LEKTOR),
'empfehlung_anrechnung' => null,
'empfehlungsanfrageAm' => (new DateTime())->format('d.m.Y'),
'empfehlungsanfrageAn' => $empfehlungsanfrage_an
);
}
// Get full name of LV Leitung.
// If LV Leitung is not present, get full name of LV lectors.
$lector_arr = $this->anrechnunglib->getLectors($item['anrechnung_id']);
$empfehlungsanfrage_an = !isEmptyArray($lector_arr)
? implode(', ', array_column($lector_arr, 'fullname'))
: '';
// Request Recommendation
if($this->anrechnunglib->requestRecommendation($item['anrechnung_id']))
{
$retval[]= array(
'anrechnung_id' => $item['anrechnung_id'],
'status_kurzbz' => self::ANRECHNUNGSTATUS_PROGRESSED_BY_LEKTOR,
'status_bezeichnung' => $this->anrechnunglib->getStatusbezeichnung(self::ANRECHNUNGSTATUS_PROGRESSED_BY_LEKTOR),
'empfehlung_anrechnung' => null,
'empfehlungsanfrageAm' => (new DateTime())->format('d.m.Y'),
'empfehlungsanfrageAn' => $empfehlungsanfrage_an
);
}
}
/**
* Send mails to lectors
* NOTE: mails are sent at the end to ensure sending only ONE mail to each LV-Leitung or lector
* even if they are required for more recommendations
* */
if (!isEmptyArray($retval))
{
self::_sendSanchoMailToLectors($retval);
// Output json to ajax
return $this->outputJsonSuccess($retval);
}
// Output json to ajax
if ($empfehlungsanfrage_an == '')
{
$this->terminateWithJsonError(
"Empfehlung wurde nicht angefordert,\nDer LV sind keine LektorInnen zugeteilt."
);
}
if (isEmptyArray($retval))
if (isEmptyArray($retval) && $counter > 0)
{
$this->terminateWithJsonError("Empfehlung wurde nicht angefordert");
return $this->outputJsonError(
"Empfehlung wurde nicht angefordert,\nDer LV sind keine LektorInnen zugeteilt."
);
}
else
{
// Output json to ajax
return $this->outputJsonSuccess($retval);
}
return $this->outputJsonError($this->p->t('ui', 'errorNichtAusgefuehrt'));
}
/**
@@ -464,33 +467,39 @@ class approveAnrechnungDetail extends Auth_Controller
/**
* Send mail to lectors asking for recommendation. (first to LV-Leitung, if not present to all lectors of lv)
* @param $anrechnung_id
* @param $mail_params
* @return bool
*/
private function _sendSanchoMailToLectors($anrechnung_id)
private function _sendSanchoMailToLectors($mail_params)
{
$lehrveranstaltung_id = $this->AnrechnungModel->load($anrechnung_id)->retval[0]->lehrveranstaltung_id;
$studiensemester_kurzbz = $this->AnrechnungModel->load($anrechnung_id)->retval[0]->studiensemester_kurzbz;
// Get Lehrveranstaltungen
$anrechnung_arr = array();
foreach ($mail_params as $item)
{
$this->AnrechnungModel->addSelect('lehrveranstaltung_id, studiensemester_kurzbz');
$anrechnung_arr[]= array(
'lehrveranstaltung_id' => $this->AnrechnungModel->load($item['anrechnung_id'])->retval[0]->lehrveranstaltung_id,
'studiensemester_kurzbz' => $this->AnrechnungModel->load($item['anrechnung_id'])->retval[0]->studiensemester_kurzbz
);
}
$anrechnung_arr = array_unique($anrechnung_arr, SORT_REGULAR);
/**
* Get mail receivers.
* If config is default (lectors): prio for LV-Leitung, if not present to all lectors of LV.
* Get lectors (prio for LV-Leitung, if not present to all lectors of LV.
* Anyway this function will receive a unique array to avoid sending more mails to one and the same lector.
* **/
if ($this->config->item('fbl') === TRUE)
{
$receiver_arr = $this->_getLeitungOfLvOe($lehrveranstaltung_id);
}
else
{
$receiver_arr = $this->_getLectors($studiensemester_kurzbz, $lehrveranstaltung_id);
}
$lector_arr = $this->_getLectors($anrechnung_arr);
// Send mail
foreach ($receiver_arr as $receiver)
// Send mail to lectors
foreach ($lector_arr as $lector)
{
$to = $receiver->uid. '@'. DOMAIN;;
$vorname = $receiver->vorname;
$to = $lector->uid;
$vorname = $lector->vorname;
// Get full name of stgl
$this->load->model('person/Person_model', 'PersonModel');
@@ -528,30 +537,35 @@ class approveAnrechnungDetail extends Auth_Controller
* @param $anrechnung_arr
* @return array
*/
private function _getLectors($studiensemester_kurzbz, $lehrveranstaltung_id)
private function _getLectors($anrechnung_arr)
{
$lector_arr = array();
$result = $this->LehrveranstaltungModel->getLecturersByLv($studiensemester_kurzbz, $lehrveranstaltung_id);
// Get lectors
foreach($anrechnung_arr as $anrechnung)
{
$this->load->model('education/Lehrveranstaltung_model', 'LehrveranstaltungModel');
$result = $this->LehrveranstaltungModel->getLecturersByLv($anrechnung['studiensemester_kurzbz'], $anrechnung['lehrveranstaltung_id']);
if (!$result = getData($result))
{
show_error('Failed retrieving lectors of Lehrveranstaltung');
}
if (!$result = getData($result))
{
show_error('Failed retrieving lectors of Lehrveranstaltung');
}
// Check if lv has LV-Leitung
$key = array_search(true, array_column($result, 'lvleiter'));
// Check if lv has LV-Leitung
$key = array_search(true, array_column($result, 'lvleiter'));
// If lv has LV-Leitung, keep only the one
if ($key !== false)
{
$lector_arr[]= $result[$key];
}
// ...otherwise keep all lectors
else
{
$lector_arr = array_merge($lector_arr, $result);
}
// If lv has LV-Leitung, keep only the one
if ($key !== false)
{
$lector_arr[]= $result[$key];
}
// ...otherwise keep all lectors
else
{
$lector_arr = array_merge($lector_arr, $result);
}
}
/**
* NOTE: This step is only done to make the array unique by uid, vorname and nachname in the following step
@@ -570,14 +584,6 @@ class approveAnrechnungDetail extends Auth_Controller
}
// Get Leitungen of Lehrveranstaltungs-Organisationseinheit
private function _getLeitungOfLvOe($lehrveranstaltung_id)
{
$result = $this->LehrveranstaltungModel->getLeitungOfLvOe($lehrveranstaltung_id);
return hasData($result) ? getData($result) : show_error('Failed retrieving Leitung of Lehrveranstaltungs-Organisationseinheit');
}
private function _saveEmpfehlungsNotiz($anrechnung_id, $empfehlungstext, $notiz_id)
{
$this->load->model('person/Notiz_model', 'NotizModel');
@@ -600,5 +606,8 @@ class approveAnrechnungDetail extends Auth_Controller
trim($empfehlungstext),
$this->_uid
);
}
}
@@ -28,9 +28,6 @@ class approveAnrechnungUebersicht extends Auth_Controller
)
);
// Load configs
$this->load->config('anrechnung');
// Load models
$this->load->model('education/Anrechnung_model', 'AnrechnungModel');
$this->load->model('education/Anrechnungstatus_model', 'AnrechnungstatusModel');
@@ -81,19 +78,6 @@ class approveAnrechnungUebersicht extends Auth_Controller
show_error(getError($studiengang_kz_arr));
}
// Get oes the user is entitled for
$oe_kurzbz_arr_schreibberechtigt = array();
if ($oe_arr = $this->permissionlib->getOE_isEntitledFor(self::BERECHTIGUNG_ANRECHNUNG_GENEHMIGEN))
{
foreach($oe_arr as $oe)
{
$berechtigt = $this->permissionlib->isBerechtigt(self::BERECHTIGUNG_ANRECHNUNG_GENEHMIGEN, 'suid', $oe);
if ($berechtigt) $oe_kurzbz_arr_schreibberechtigt[]= $oe;
}
}
// Check if permission is readonly
$hasReadOnlyAccess =
$this->permissionlib->isBerechtigt(self::BERECHTIGUNG_ANRECHNUNG_GENEHMIGEN, 's')
&& !$this->permissionlib->isBerechtigt(self::BERECHTIGUNG_ANRECHNUNG_GENEHMIGEN, 'suid');
@@ -103,11 +87,9 @@ class approveAnrechnungUebersicht extends Auth_Controller
$viewData = array(
'studiensemester_selected' => $studiensemester_kurzbz,
'studiengaenge_entitled' => $studiengang_kz_arr, // alle STG mit Lese- und Schreibberechtigung
'oes_schreibberechtigt' => $oe_kurzbz_arr_schreibberechtigt, // alle STG nur mit Schreibberechtigung
'studiengaenge_entitled' => $studiengang_kz_arr,
'hasReadOnlyAccess' => $hasReadOnlyAccess,
'hasCreateAnrechnungAccess' => $hasCreateAnrechnungAccess,
'configFachbereichsleitung' => $this->config->item('fbl')
'hasCreateAnrechnungAccess' => $hasCreateAnrechnungAccess
);
$this->load->view('lehre/anrechnung/approveAnrechnungUebersicht.php', $viewData);
@@ -225,20 +207,14 @@ class approveAnrechnungUebersicht extends Auth_Controller
// Request Recommendation
if($this->anrechnunglib->requestRecommendation($item['anrechnung_id']))
{
// Get full name of Fachbereichsleitung or LV Leitung.
if($this->config->item('fbl') === TRUE)
{
$result = $this->anrechnunglib->getLeitungOfLvOe($item['anrechnung_id']);
}
else
{
// If LV Leitung is not present, get full name of LV lectors.
$result = $this->anrechnunglib->getLectors($item['anrechnung_id']);
}
// Get full name of LV Leitung.
// If LV Leitung is not present, get full name of LV lectors.
$lector_arr = $this->anrechnunglib->getLectors($item['anrechnung_id']);
$empfehlungsanfrage_an = !isEmptyArray($lector_arr)
? implode(', ', array_column($lector_arr, 'fullname'))
: '';
$empfehlungsanfrage_an = !isEmptyArray($result) ? implode(', ', array_column($result, 'fullname')) : '';
$retval[]= array(
$retval[]= array(
'anrechnung_id' => $item['anrechnung_id'],
'status_kurzbz' => self::ANRECHNUNGSTATUS_PROGRESSED_BY_LEKTOR,
'status_bezeichnung' => $this->anrechnunglib->getStatusbezeichnung(self::ANRECHNUNGSTATUS_PROGRESSED_BY_LEKTOR),
@@ -249,18 +225,23 @@ class approveAnrechnungUebersicht extends Auth_Controller
}
}
// Output json to ajax
if (isEmptyArray($retval))
/**
* Send mails to lectors
* NOTE: mails are sent at the end to ensure sending only ONE mail to each LV-Leitung or lector
* even if they are required for more recommendations
* */
if (!isEmptyArray($retval))
{
if ($counter > 0)
{
$this->terminateWithJsonError('Bei '. $counter.' LV sind keine LektorInnen zugeteilt.');
}
$this->terminateWithJsonError('Es wurden keine Empfehlungen angefordert');
self::_sendSanchoMailToLectors($retval);
}
$this->outputJsonSuccess($retval);
// Output json to ajax
if (isEmptyArray($retval) && $counter == 0)
{
return $this->outputJsonError('Es wurden keine Empfehlungen angefordert');
}
return $this->outputJsonSuccess($retval);
}
/**
@@ -335,7 +316,7 @@ class approveAnrechnungUebersicht extends Auth_Controller
* @param $mail_params
* @return bool
*/
private function _sendSanchoMail($mail_params)
private function _sendSanchoMailToLectors($mail_params)
{
// Get Lehrveranstaltungen
$anrechnung_arr = array();
@@ -351,25 +332,18 @@ class approveAnrechnungUebersicht extends Auth_Controller
$anrechnung_arr = array_unique($anrechnung_arr, SORT_REGULAR);
/**
* Get mail receivers.
* If retrieving lectors: prio for LV-Leitung, if not present to all lectors of LV.
* This function will receive a unique array to avoid sending more mails to one and the same user.
**/
if($this->config->item('fbl') === TRUE)
{
$receiver_arr = $this->_getLeitungOfLvOe($anrechnung_arr);
}
else
{
$receiver_arr = $this->_getLectors($anrechnung_arr);
}
/**
* Get lectors (prio for LV-Leitung, if not present to all lectors of LV.
* Anyway this function will receive a unique array to avoid sending more mails to one and the same lector.
* **/
$lector_arr = $this->_getLectors($anrechnung_arr);
// Send mail to lectors
foreach ($receiver_arr as $receiver)
foreach ($lector_arr as $lector)
{
$to = $receiver->uid. '@'. DOMAIN;
$vorname = $receiver->vorname;
$to = $lector->uid;
$vorname = $lector->vorname;
// Get full name of stgl
$this->load->model('person/Person_model', 'PersonModel');
@@ -453,34 +427,4 @@ class approveAnrechnungUebersicht extends Auth_Controller
return $lector_arr;
}
/**
* Get Leitungen of Lehrveranstaltungs-Organisationseinheit with unique uids.
*
* @param $anrechnung_arr
* @return array
*/
private function _getLeitungOfLvOe($anrechnung_arr)
{
$oeLeitung_arr = array();
// Get Leitungen
foreach($anrechnung_arr as $anrechnung)
{
$this->load->model('education/Lehrveranstaltung_model', 'LehrveranstaltungModel');
$result = $this->LehrveranstaltungModel->getLeitungOfLvOe($anrechnung['lehrveranstaltung_id']);
if (!hasData($result))
{
show_error('No Leitung found');
}
$oeLeitung_arr = array_merge($oeLeitung_arr, getData($result));
}
// Make array unique
$oeLeitung_arr = array_unique($oeLeitung_arr, SORT_REGULAR);
return $oeLeitung_arr;
}
}
@@ -80,7 +80,11 @@ class requestAnrechnung extends Auth_Controller
$prestudent_id = getData($result)[0]->prestudent_id;
// Check if application deadline is expired
$is_expired = $this->_isExpired($studiensemester_kurzbz);
$is_expired = self::_isExpired(
$this->config->item('submit_application_start'),
$this->config->item('submit_application_end'),
$studiensemester_kurzbz
);
// Check if Lehrveranstaltung was already graded with application blocking grades
$is_blocked = self::_LVhasBlockingGrades($studiensemester_kurzbz, $lehrveranstaltung_id);
@@ -89,7 +93,7 @@ class requestAnrechnung extends Auth_Controller
$anrechnungData = $this->anrechnunglib->getAnrechnungDataByLv($lehrveranstaltung_id, $studiensemester_kurzbz, $prestudent_id);
// Get Antrag data
$antragData = $this->anrechnunglib->getAntragData($prestudent_id, $studiensemester_kurzbz, $lehrveranstaltung_id, $anrechnungData->anrechnung_id);
$antragData = $this->anrechnunglib->getAntragData($prestudent_id, $studiensemester_kurzbz, $lehrveranstaltung_id);
$viewData = array(
'antragData' => $antragData,
@@ -111,8 +115,6 @@ class requestAnrechnung extends Auth_Controller
$lehrveranstaltung_id = $this->input->post('lv_id');
$studiensemester_kurzbz = $this->input->post('studiensemester');
$bestaetigung = $this->input->post('bestaetigung');
$begruendung_ects = $this->input->post('begruendung_ects');
$begruendung_lvinhalt = $this->input->post('begruendung_lvinhalt');
// Validate data
if (empty($_FILES['uploadfile']['name']))
@@ -123,9 +125,7 @@ class requestAnrechnung extends Auth_Controller
if (isEmptyString($begruendung_id) ||
isEmptyString($anmerkung) ||
isEmptyString($lehrveranstaltung_id) ||
isEmptyString($studiensemester_kurzbz) ||
isEmptyString($begruendung_ects) ||
isEmptyString($begruendung_lvinhalt))
isEmptyString($studiensemester_kurzbz))
{
return $this->outputJsonError($this->p->t('ui', 'errorFelderFehlen'));
}
@@ -152,10 +152,10 @@ class requestAnrechnung extends Auth_Controller
return $this->outputJsonError($this->p->t('anrechnung', 'antragBereitsGestellt'));
}
// Exit if application is a past ( < actual ) studysemester
if (self::_applicationIsPastSS($studiensemester_kurzbz))
// Exit if application is not for actual studysemester
if (!self::_applicationIsForActualSS($studiensemester_kurzbz))
{
return $this->outputJsonError($this->p->t('anrechnung', 'antragNichtFuerVerganganeSS'));
return $this->outputJsonError($this->p->t('anrechnung', 'antragNurImAktSS'));
}
// Upload document
@@ -176,9 +176,7 @@ class requestAnrechnung extends Auth_Controller
$lehrveranstaltung_id,
$begruendung_id,
$lastInsert_dms_id,
$anmerkung,
$begruendung_ects,
$begruendung_lvinhalt
$anmerkung
);
if (isError($result))
@@ -236,30 +234,32 @@ class requestAnrechnung extends Auth_Controller
* @return bool True if deadline is expired
* @throws Exception
*/
private function _isExpired($studiensemester_kurzbz)
private function _isExpired($start, $ende, $studiensemester_kurzbz)
{
$today = new DateTime('today midnight');
$this->load->model('organisation/Studiensemester_model', 'StudiensemesterModel');
// Load all Anrechnungszeitfenster for this Studiensemester
$this->load->model('education/Anrechnungszeitraum_model', 'AnrechnungszeitraumModel');
$result = $this->AnrechnungszeitraumModel->loadWhere(array('studiensemester_kurzbz' => $studiensemester_kurzbz));
// If start is not given, set to Semesterstart.
if (!isset($start) || isEmptyString($start))
{
$this->StudiensemesterModel->addSelect('start');
$result = $this->StudiensemesterModel->load($studiensemester_kurzbz);
$start = getData($result)[0]->start;
}
if (hasData($result))
{
// Loop through Anrechnungszeitfenster
foreach (getData($result) as $azrObj)
{
$start = new DateTime($azrObj->anrechnungstart);
$ende = new DateTime($azrObj->anrechnungende);
// If ende is not given, set to Semesterende.
if (!isset($ende) || isEmptyString($ende))
{
$this->StudiensemesterModel->addSelect('ende');
$result = $this->StudiensemesterModel->load($studiensemester_kurzbz);
$ende = getData($result)[0]->ende;
}
// Return false if today is at least within one Anrechnungszeitraum
if (($today >= $start && $today <= $ende)) return false;
$today = new DateTime('today midnight');
$start = new DateTime($start);
$ende = new DateTime($ende);
}
}
// Return true if today is in none Anrechnungszeitraum
return true;
// True if expired
return ($today < $start || $today > $ende);
}
/**
@@ -312,21 +312,18 @@ class requestAnrechnung extends Auth_Controller
}
/**
* Check if applications' study semester is < actual study semester.
* Check if applications' study semester is actual study semester.
*
* @param $studiensemester_kurzbz
* @return bool
*/
private function _applicationIsPastSS($studiensemester_kurzbz)
private function _applicationIsForActualSS($studiensemester_kurzbz)
{
$this->load->model('organisation/Studiensemester_model', 'StudiensemesterModel');
$result = $this->StudiensemesterModel->getNearest();
$actual_ss = getData($result)[0];
$actual_ss = getData($result)[0]->studiensemester_kurzbz;
$result = $this->StudiensemesterModel->load($studiensemester_kurzbz);
$anrechnung_ss = getData($result)[0];
return $anrechnung_ss->ende < $actual_ss->start;
return $studiensemester_kurzbz == $actual_ss;
}
private function _LVhasBlockingGrades($studiensemester_kurzbz, $lehrveranstaltung_id)
@@ -28,9 +28,6 @@ class reviewAnrechnungDetail extends Auth_Controller
)
);
// Load configs
$this->load->config('anrechnung');
// Load models
$this->load->model('education/Anrechnung_model', 'AnrechnungModel');
$this->load->model('education/Anrechnungstatus_model', 'AnrechnungstatusModel');
@@ -87,21 +84,16 @@ class reviewAnrechnungDetail extends Auth_Controller
$antragData = $this->anrechnunglib->getAntragData(
$anrechnungData->prestudent_id,
$anrechnungData->studiensemester_kurzbz,
$anrechnungData->lehrveranstaltung_id,
$anrechnungData->anrechnung_id
$anrechnungData->lehrveranstaltung_id
);
// Get Empfehlung data
$empfehlungData = $this->anrechnunglib->getEmpfehlungData($anrechnung_id);
// False if LV-Leitung is present and user is not LV-Leitung. Otherwise always true.
$isEmpfehlungsberechtigt = $this->anrechnunglib->isEmpfehlungsberechtigt($anrechnung_id);
$viewData = array(
'antragData' => $antragData,
'anrechnungData' => $anrechnungData,
'empfehlungData' => $empfehlungData,
'isEmpfehlungsberechtigt' => $isEmpfehlungsberechtigt
'empfehlungData' => $empfehlungData
);
$this->load->view('lehre/anrechnung/reviewAnrechnungDetail.php', $viewData);
@@ -148,13 +140,10 @@ class reviewAnrechnungDetail extends Auth_Controller
* Send mails to STGL (if not present STGL, send to STGL assistance)
* NOTE: mails are sent at the end to ensure sending only one mail to each STGL
* */
if ($this->config->item('send_mail') === TRUE)
{
if (!$this->_sendSanchoMails($json, true))
{
return $this->outputJsonError('Failed sending emails');
}
}
if (!$this->_sendSanchoMails($json, true))
{
return $this->outputJsonError('Failed sending emails');
}
return $this->outputJsonSuccess($json);
}
@@ -202,13 +191,10 @@ class reviewAnrechnungDetail extends Auth_Controller
if (isset($json) && !isEmptyArray($json))
{
// Send mails to STGL (if not present STGL, send to STGL assistance)
if ($this->config->item('send_mail') === TRUE)
{
if (!$this->_sendSanchoMails($json, false))
{
return $this->outputJsonError('Failed sending emails');
}
}
if (!$this->_sendSanchoMails($json, false))
{
return $this->outputJsonError('Failed sending emails');
}
return $this->outputJsonSuccess($json);
}
@@ -267,14 +253,8 @@ class reviewAnrechnungDetail extends Auth_Controller
show_error('Failed retrieving Anrechnung');
}
if($this->config->item('fbl') === TRUE)
{
$result = $this->LehrveranstaltungModel->getLeitungOfLvOe($result->lehrveranstaltung_id);
}
else
{
$result = $this->LehrveranstaltungModel->getLecturersByLv($result->studiensemester_kurzbz, $result->lehrveranstaltung_id);
}
$result = $this->LehrveranstaltungModel
->getLecturersByLv($result->studiensemester_kurzbz, $result->lehrveranstaltung_id);
if($result = getData($result))
{
@@ -302,20 +282,14 @@ class reviewAnrechnungDetail extends Auth_Controller
show_error('Failed retrieving Anrechnung');
}
if($this->config->item('fbl') === TRUE)
{
$result = $this->LehrveranstaltungModel->getLeitungOfLvOe($result->lehrveranstaltung_id);
}
else
{
$result = $this->LehrveranstaltungModel->getLecturersByLv($result->studiensemester_kurzbz, $result->lehrveranstaltung_id);
}
$result = $this->LehrveranstaltungModel
->getLecturersByLv($result->studiensemester_kurzbz, $result->lehrveranstaltung_id);
if($result = getData($result))
{
$entitled_uid_arr = array_column($result, 'uid');
$entitled_lector_arr = array_column($result, 'uid');
if (in_array($this->_uid, $entitled_uid_arr))
if (in_array($this->_uid, $entitled_lector_arr))
{
return;
}
@@ -26,9 +26,6 @@ class reviewAnrechnungUebersicht extends Auth_Controller
)
);
// Load configs
$this->load->config('anrechnung');
// Load models
$this->load->model('education/Anrechnung_model', 'AnrechnungModel');
$this->load->model('education/Anrechnungstatus_model', 'AnrechnungstatusModel');
@@ -75,8 +72,7 @@ class reviewAnrechnungUebersicht extends Auth_Controller
}
$viewData = array(
'studiensemester_selected' => $studiensemester_kurzbz,
'configFachbereichsleitung' => $this->config->item('fbl')
'studiensemester_selected' => $studiensemester_kurzbz
);
$this->load->view('lehre/anrechnung/reviewAnrechnungUebersicht.php', $viewData);
@@ -115,19 +111,16 @@ class reviewAnrechnungUebersicht extends Auth_Controller
* Send mails to STGL (if not present STGL, send to STGL assistance)
* NOTE: mails are sent at the end to ensure sending only one mail to each STGL
* */
if ($this->config->item('send_mail') === TRUE)
{
if (!$this->_sendSanchoMails($json, true))
{
show_error('Failed sending emails');
}
}
if (!$this->_sendSanchoMails($json, true))
{
show_error('Failed sending emails');
}
return $this->outputJsonSuccess($json);
}
else
{
$this->terminateWithJsonError($this->p->t('ui', 'errorNichtAusgefuehrt'));
return $this->outputJsonError($this->p->t('ui', 'errorNichtAusgefuehrt'));
}
}
@@ -161,13 +154,10 @@ class reviewAnrechnungUebersicht extends Auth_Controller
if (isset($json) && !isEmptyArray($json))
{
// Send mails to STGL (if not present STGL, send to STGL assistance)
if ($this->config->item('send_mail') === TRUE)
{
if (!$this->_sendSanchoMails($json, false))
{
show_error('Failed sending emails');
}
}
if (!$this->_sendSanchoMails($json, false))
{
show_error('Failed sending emails');
}
return $this->outputJsonSuccess($json);
}
@@ -227,20 +217,14 @@ class reviewAnrechnungUebersicht extends Auth_Controller
show_error('Failed retrieving Anrechnung');
}
if ($this->config->item('fbl') === TRUE)
{
$result = $this->LehrveranstaltungModel->getLeitungOfLvOe($result->lehrveranstaltung_id);
}
else
{
$result = $this->LehrveranstaltungModel->getLecturersByLv($result->studiensemester_kurzbz, $result->lehrveranstaltung_id);
}
$result = $this->LehrveranstaltungModel
->getLecturersByLv($result->studiensemester_kurzbz, $result->lehrveranstaltung_id);
if($result = getData($result))
{
$entitled_uid_arr = array_column($result, 'uid');
$entitled_lector_arr = array_column($result, 'uid');
if (in_array($this->_uid, $entitled_uid_arr))
if (in_array($this->_uid, $entitled_lector_arr))
{
return;
}
@@ -35,7 +35,6 @@ class LehrauftragAkzeptieren extends Auth_Controller
$this->load->model('ressource/Mitarbeiter_model', 'MitarbeiterModel');
$this->load->model('codex/Bisverwendung_model', 'BisverwendungModel');
$this->load->model('person/Benutzer_model', 'BenutzerModel');
$this->load->model('vertragsbestandteil/Dienstverhaeltnis_model', 'DienstverhaeltnisModel');
// Load libraries
$this->load->library('WidgetLib');
@@ -95,9 +94,9 @@ class LehrauftragAkzeptieren extends Auth_Controller
'lektor' => true,
'aktiv' => true
));
$is_external_lector = hasData($result) ? true : false;
$view_data = array(
'studiensemester_selected' => $studiensemester_kurzbz,
'is_external_lector' => $is_external_lector
@@ -208,41 +207,15 @@ class LehrauftragAkzeptieren extends Auth_Controller
*/
public function checkInkludierteLehre()
{
if(defined('DIENSTVERHAELTNIS_SUPPORT') && DIENSTVERHAELTNIS_SUPPORT)
{
// Bei neuer Vertragsstruktur wird nur anhand des echten DVs entschieden ob eine Anzeige
// des Stundensatzes erfolgt oder nicht.
$result = $this->DienstverhaeltnisModel->getDVByPersonUID($this->_uid, null, date('Y-m-d'));
$result = $this->BisverwendungModel->getLast($this->_uid, false);
if (hasData($result))
{
$data = getData($result);
foreach($data as $row)
{
if($row->vertragsart_kurzbz == 'echterdv')
$this->outputJsonSuccess(true);
else
$this->outputJsonSuccess(false);
}
}
else
{
$this->outputJsonError(getError($result));
}
if (hasData($result))
{
$this->outputJsonSuccess(!is_null($result->retval[0]->inkludierte_lehre) && $result->retval[0]->inkludierte_lehre != 0);
}
else
{
// DEPRECATED
$result = $this->BisverwendungModel->getLast($this->_uid, false);
if (hasData($result))
{
$this->outputJsonSuccess(!is_null($result->retval[0]->inkludierte_lehre) && $result->retval[0]->inkludierte_lehre != 0);
}
else
{
$this->outputJsonError(getError($result));
}
$this->outputJsonError(getError($result));
}
}
@@ -1,43 +0,0 @@
<?php
if (! defined('BASEPATH')) exit('No direct script access allowed');
class Components extends FHC_Controller
{
/**
* @return void
*/
public function primevue(...$args)
{
$path = implode('/', $args);
$target = FHCPATH . 'vendor/npm-asset/primevue/' . $path;
if (!file_exists($target))
return show_404();
$newUrl = str_repeat('../', count($args));
$ext = substr($path, -7) == '.min.js' ? '.esm.min.js' : '.esm.js';
$contents = file_get_contents($target);
$contents = preg_replace_callback('/import([^;]*)from\s*[\'"]vue[\'"];/i', function ($matches) {
return 'let ' . str_replace(' as ', ': ', $matches[1]) . ' = Vue;';
}, $contents);
$contents = preg_replace_callback('/(import[^;]*[\'"])(primevue[^\'"]+)([\'"])/i', function ($matches) use ($ext, $newUrl) {
if (is_file(FHCPATH . 'vendor/npm-asset/' . $matches[2])) {
$newUrl .= $matches[2];
} else {
$testfile = $matches[2] . '/index' . $ext;
if (file_exists(FHCPATH . 'vendor/npm-asset/' . $testfile))
$newUrl .= $testfile;
else
$newUrl .= $matches[2] . strrchr($matches[2], '/') . $ext;
}
return $matches[1] . $newUrl . $matches[3];
}, $contents);
$this->output->set_content_type('text/javascript');
$this->output->set_output($contents);
}
}
@@ -1,711 +0,0 @@
<?php
/*
* Job zur einmaligen Migration der Mitarbeiterverträge aus der tbl_bisverwendung in die neue
* Vertragsstruktur im HR Schema
*
* Aufruf pro Person
* php index.ci.php system/MigrateContract/index/oesi
*
* Aufruf fuer Alle
* php index.ci.php system/MigrateContract/index
*/
if (! defined('BASEPATH')) exit('No direct script access allowed');
class MigrateContract extends CLI_Controller
{
private $matching_ba1_vertragsart;
private $OE_DEFAULT = 'gst';
/**
* Constructor
*/
public function __construct()
{
parent::__construct();
$this->load->model('codex/bisverwendung_model', 'BisVerwendungModel');
$this->load->model('person/benutzerfunktion_model', 'BenutzerfunktionModel');
$this->matching_ba1_vertragsart = array(
'101'=>'externerlehrender',
'102'=>'DV anderen Gebietskörperschaft',
'103'=>'echterdv',
'104'=>'studentischehilfskr',
'105'=>'externerlehrender',
'106'=>'Andere Bildungseinrichtung',
'107'=>'werkvertrag',
'108'=>'studentischehilfskr',
'109'=>'ueberlassungsvertrag',
'110'=>'echterfreier',
'111'=>'echterdv', //All-In
);
}
// -----------------------------------------------------------------------------------------------------------------
// Public methods
/**
* Everything has a beginning
*/
public function index($user = null)
{
if (!is_null($user))
{
$contracts = $this->_transformUser($user);
/*
Format:
$contracts['dv'][]['vbs'][]
*/
//$this->outputJson($contracts);
var_dump($contracts);
$this->_saveJSON($contracts);
}
else
{
$qry = "SELECT distinct mitarbeiter_uid FROM bis.tbl_bisverwendung";
$db = new DB_Model();
$resultUser = $db->execReadOnlyQuery($qry);
if (hasData($resultUser))
{
$users = getData($resultUser);
foreach($users as $user)
{
$contracts = $this->_transformUser($user->mitarbeiter_uid);
$this->_saveJSON($contracts);
}
}
}
}
private function _saveJSON($contracts)
{
$this->load->model('vertragsbestandteil/Dienstverhaeltnis_model','DienstverhaeltnisModel');
$this->load->model('vertragsbestandteil/Vertragsbestandteil_model','VertragsbestandteilModel');
$this->load->model('vertragsbestandteil/VertragsbestandteilStunden_model','VertragsbestandteilStundenModel');
$this->load->model('vertragsbestandteil/VertragsbestandteilZeitaufzeichnung_model','VertragsbestandteilZeitaufzeichnungModel');
$this->load->model('vertragsbestandteil/VertragsbestandteilFreitext_model','VertragsbestandteilFreitextModel');
$this->load->model('vertragsbestandteil/VertragsbestandteilFunktion_model','VertragsbestandteilFunktionModel');
$this->load->model('vertragsbestandteil/VertragsbestandteilKarenz_model','VertragsbestandteilKarenzModel');
$failed = false;
$this->db->trans_begin();
foreach($contracts['dv'] as $row_dv)
{
// Dienstvertrag erstellen
$resultDV = $this->DienstverhaeltnisModel->insert(
array(
'mitarbeiter_uid' => $row_dv['mitarbeiter_uid'],
'vertragsart_kurzbz' => $row_dv['vertragsart_kurzbz'],
'oe_kurzbz' => $row_dv['oe_kurzbz'],
'von' => $row_dv['von'],
'bis' => $row_dv['bis'],
'insertamum' => date('Y-m-d H:i:s'),
'insertvon' => 'MigrateContract'
)
);
if (isSuccess($resultDV) && hasData($resultDV))
{
$dv_id = getData($resultDV);
// Vertragsbetandteile erstellen
foreach($row_dv['vbs'] as $row_vbs)
{
$resultVBS = $this->VertragsbestandteilModel->insert(
array(
'dienstverhaeltnis_id' => $dv_id,
'vertragsbestandteiltyp_kurzbz' => $row_vbs['vertragsbestandteiltyp_kurzbz'],
'von' => $row_vbs['von'],
'bis' => $row_vbs['bis'],
'insertamum' => date('Y-m-d H:i:s'),
'insertvon' => 'MigrateContract'
)
);
if (isSuccess($resultVBS) && hasData($resultVBS))
{
$vbs_id = getData($resultVBS);
echo 'VBS:'.$vbs_id;
switch($row_vbs['vertragsbestandteiltyp_kurzbz'])
{
case 'stunden':
$resultVBS = $this->_insertVBSStunden($vbs_id, $row_vbs);
break;
case 'zeitaufzeichnung':
$resultVBS = $this->_insertVBSZeitaufzeichnung($vbs_id, $row_vbs);
break;
case 'funktion':
$resultVBS = $this->_insertVBSFunktion($vbs_id, $row_vbs);
break;
case 'freitext':
$resultVBS = $this->_insertVBSFreitext($vbs_id, $row_vbs);
break;
case 'karenz':
$resultVBS = $this->_insertVBSKarenz($vbs_id, $row_vbs);
break;
}
if (isError($resultVBS))
{
echo "FAILED:".getError($resultVBS);
$failed = true;
}
}
else
{
$failed = true;
}
}
}
else
{
$failed = true;
}
}
if(!$failed)
{
$this->db->trans_commit();
}
else
{
echo "ROLLBACK";
$this->db->trans_rollback();
}
}
private function _insertVBSKarenz($vbs_id, $row_vbs)
{
return $this->VertragsbestandteilKarenzModel->insert(
array(
'vertragsbestandteil_id' => $vbs_id,
'karenztyp_kurzbz' => $row_vbs['karenztyp_kurzbz']
)
);
}
private function _insertVBSFreitext($vbs_id, $row_vbs)
{
return $this->VertragsbestandteilFreitextModel->insert(
array(
'vertragsbestandteil_id' => $vbs_id,
'freitexttyp_kurzbz' => $row_vbs['freitexttyp_kurzbz'],
'titel' => $row_vbs['titel'],
'anmerkung' => $row_vbs['anmerkung']
)
);
}
private function _insertVBSFunktion($vbs_id, $row_vbs)
{
return $this->VertragsbestandteilFunktionModel->insert(
array(
'vertragsbestandteil_id' => $vbs_id,
'benutzerfunktion_id' => $row_vbs['benutzerfunktion_id']
)
);
}
private function _insertVBSZeitaufzeichnung($vbs_id, $row_vbs)
{
return $this->VertragsbestandteilZeitaufzeichnungModel->insert(
array(
'vertragsbestandteil_id' => $vbs_id,
'zeitaufzeichnung' => $row_vbs['zeitaufzeichnung'],
'azgrelevant' => $row_vbs['azgrelevant'],
'homeoffice' => $row_vbs['homeoffice']
)
);
}
private function _insertVBSStunden($vbs_id, $row_vbs)
{
return $this->VertragsbestandteilStundenModel->insert(
array(
'vertragsbestandteil_id' => $vbs_id,
'wochenstunden' => $row_vbs['wochenstunden'],
'teilzeittyp_kurzbz' => $row_vbs['teilzeittyp_kurzbz']
)
);
}
/**
* Ermittelt die neue Vertragsstruktur fuer einen User
*/
private function _transformUser($user)
{
$contracts = array();
$this->BisVerwendungModel->addOrder('beginn');
$result_verwendung = $this->BisVerwendungModel->loadWhere(array("mitarbeiter_uid" => $user));
if (isError($result_verwendung))
die("Failed to load Verwendung");
if (hasData($result_verwendung))
{
$verwendung = getData($result_verwendung);
foreach ($verwendung as $row_verwendung)
{
$dv = $this->_getOrCreateDV($contracts, $row_verwendung);
// Ende des DV aktualisieren
if ($contracts['dv'][$dv]['bis'] < $row_verwendung->ende || $row_verwendung->ende == '')
$contracts['dv'][$dv]['bis'] = $row_verwendung->ende;
// Stundenbestandteil pruefen
$this->_addVertragsbestandteilStunden($contracts, $dv, $row_verwendung);
// Befristung
$this->_addVertragsbestandteilFreitextBefristung($contracts, $dv, $row_verwendung);
// All-In
$this->_addVertragsbestandteilFreitextAllIn($contracts, $dv, $row_verwendung);
// Zeitaufzeichnung
$this->_addVertragsbestandteilZeitaufzeichnung($contracts, $dv, $row_verwendung);
// Karenz
$this->_addVertragsbestandteilKarenz($contracts, $dv, $row_verwendung);
// Inkludierte Lehre
// Kuendigungsfrist
// Urlaubsanspruch
}
// Funktion
$this->_addVertragsbestandteilFunktion($contracts, $user);
}
return $contracts;
}
/**
* Fuegt Karenzierungseintraege zu bestehenden Dienstverhaeltnissen hinzu
*/
private function _addVertragsbestandteilKarenz(&$contracts, $dv, $row_verwendung)
{
if ($row_verwendung->beschausmasscode == 5)
{
$dtstart = new DateTime($row_verwendung->beginn);
$dtende = new DateTime($row_verwendung->ende);
$interval = $dtende->diff($dtstart);
$dauer = $interval->format('%a');
// TODO: klären ob das so machbar ist
if ($dauer < 65)
$karenztyp = 'papamonat';
elseif ($dauer < 120)
$karenztyp = 'bildungskarenz';
else
$karenztyp = 'elternkarenz';
// VBS anlegen und Funktion zuweisen
$newVBSIndex = $this->_getNewVBSIndex($contracts, $dv);
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['vertragsbestandteiltyp_kurzbz'] = 'karenz';
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['von'] = $row_verwendung->beginn;
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['bis'] = $row_verwendung->ende;
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['karenztyp_kurzbz'] = $karenztyp;
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['geplanter_geburtstermin'] = null;
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['tatsaechlicher_geburtstermin'] = null;
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['hint'] = 'Dauer:'.$dauer;
}
}
/**
* Holt die Funktionen die Vertragsrelevant sind und verknüpft diese
*/
private function _addVertragsbestandteilFunktion(&$contracts, $user)
{
// Alle Funktionen holen die Vertragsrelevant sind
$this->BenutzerfunktionModel->addOrder('datum_von');
$this->BenutzerfunktionModel->addJoin('public.tbl_funktion','funktion_kurzbz');
$resultFunktionen = $this->BenutzerfunktionModel->loadWhere(array('uid' => $user, 'vertragsrelevant' => true));
if (isSuccess($resultFunktionen) && hasData($resultFunktionen))
{
$funktionen = getData($resultFunktionen);
foreach ($funktionen as $row_funktion)
{
$funktion_added = 0;
$dv = '';
// Passendes DV suchen
foreach ($contracts['dv'] as $key_dv => $row_contract)
{
// Eine Funktion kann zu mehreren DV zugeordnet sein
// es werden daher alle durchsucht ob es reinfaellt und ggf mehrfach zugeordnet
if ((isset($row_funktion->datum_von) && $row_funktion->datum_von >= $row_contract['von'])
&& ($row_contract['bis'] == '' || $row_contract['bis'] >= $row_funktion->datum_von)
&& (
(
isset($row_funktion->datum_bis) && isset($row_contract['bis'])
&& $row_funktion->datum_bis <= $row_contract['bis']
)
|| $row_funktion->datum_bis == ''
|| (isset($row_funktion->datum_bis) && !isset($row_contract['bis']))
)
)
{
$dv = $key_dv;
// Startdatum und Endedatum ermitteln wenn die Funktion ueber das DV hinausgeht
// Wenn die Dauer laenger ist, wird beim Beginn/Ende des DV abgegrenzt
$dtstart_fkt = new DateTime($row_funktion->datum_von);
$dtstart_dv = new DateTime($row_contract['von']);
if ($dtstart_fkt < $dtstart_dv)
$startdatum = $row_contract['von'];
else
$startdatum = $row_funktion->datum_von;
$dtende_fkt = new DateTime($row_funktion->datum_bis);
$dtende_dv = new DateTime($row_contract['bis']);
if ($dtende_fkt < $dtende_dv)
$endedatum = $row_funktion->datum_bis;
else
$endedatum = $row_contract['bis'];
// VBS anlegen und Funktion zuweisen
$newVBSIndex = $this->_getNewVBSIndex($contracts, $dv);
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['vertragsbestandteiltyp_kurzbz'] = 'funktion';
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['von'] = $startdatum;
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['bis'] = $endedatum;
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['benutzerfunktion_id'] = $row_funktion->benutzerfunktion_id;
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['hint'] = $row_funktion->funktion_kurzbz.' '.$row_funktion->datum_von.' - '.$row_funktion->datum_bis;
$funktion_added++;
}
}
if ($funktion_added == 0)
{
echo "\nFunktion nicht zugeordnet: ".$row_funktion->funktion_kurzbz.' '.$row_funktion->datum_von.' - '.$row_funktion->datum_bis;
}
}
}
}
/**
* Prueft ob schon ein Vertragsbestandteil fuer Zeitaufzeichnung vorhanden ist das in den Zeitraum passt
* bzw direkt anschließt. Wenn es direkt anschließend ist und die Art gleich sind wird die Laufzeit verlaengert
* Ansonsten wird ein neuer VBS angelegt
*/
private function _addVertragsbestandteilZeitaufzeichnung(&$contracts, $dv, $row_verwendung)
{
if (isset($contracts['dv'][$dv]['vbs']))
{
foreach ($contracts['dv'][$dv]['vbs'] as $index_vbs=>$row_vbs)
{
if ($row_vbs['vertragsbestandteiltyp_kurzbz'] == 'zeitaufzeichnung')
{
if ($this->_isVBSAngrenzend($row_verwendung, $row_vbs)
&& $row_vbs['zeitaufzeichnung'] == $row_verwendung->zeitaufzeichnungspflichtig
&& $row_vbs['azgrelevant'] == $row_verwendung->azgrelevant
&& $row_vbs['homeoffice'] == $row_verwendung->homeoffice
)
{
// Zeitaufzeichnungsarten bleiben gleich - Ende des VBS verlaengern
$contracts['dv'][$dv]['vbs'][$index_vbs]['bis'] = $row_verwendung->ende;
return true;
}
}
}
}
// kein passender VBS gefunden - neuen anlegen
$newVBSIndex = $this->_getNewVBSIndex($contracts, $dv);
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['vertragsbestandteiltyp_kurzbz'] = 'zeitaufzeichnung';
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['von'] = $row_verwendung->beginn;
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['bis'] = $row_verwendung->ende;
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['zeitaufzeichnung'] = $row_verwendung->zeitaufzeichnungspflichtig;
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['azgrelevant'] = $row_verwendung->azgrelevant;
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['homeoffice'] = $row_verwendung->homeoffice;
return true;
}
/**
* Fueg einen Freitextbestandteil fuer All-In zum DV hinzu
*/
private function _addVertragsbestandteilFreitextAllIn(&$contracts, $dv, $row_verwendung)
{
if ($row_verwendung->ba1code == 111) // All-In
{
$newVBSIndex = $this->_getNewVBSIndex($contracts, $dv);
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['vertragsbestandteiltyp_kurzbz'] = 'freitext';
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['von'] = $row_verwendung->beginn;
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['bis'] = $row_verwendung->ende;
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['freitexttyp_kurzbz'] = 'allin';
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['titel'] = 'allin';
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['anmerkung'] = 'allin';
}
return true;
}
/**
* Fueg einen Freitextbestandteil fuer die Berfristung zum DV hinzu
*/
private function _addVertragsbestandteilFreitextBefristung(&$contracts, $dv, $row_verwendung)
{
if ($row_verwendung->ba2code == 1) // Befristung
{
$newVBSIndex = $this->_getNewVBSIndex($contracts, $dv);
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['vertragsbestandteiltyp_kurzbz'] = 'freitext';
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['von'] = $row_verwendung->beginn;
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['bis'] = $row_verwendung->ende;
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['freitexttyp_kurzbz'] = 'befristung';
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['titel'] = 'befristung';
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['anmerkung'] = 'befristung';
}
return true;
}
/**
* Prueft ob schon ein Vertragsbestandteil mit diesem Stundenausmass vorhanden ist das in den Zeitraum passt
* bzw direkt anschließt. Wenn es direkt anschließend ist und die Stunden gleich sind wird die Laufzeit verlaengert
* Ansonsten wird ein neuer VBS angelegt
*/
private function _addVertragsbestandteilStunden(&$contracts, $dv, $row_verwendung)
{
// Nur anlegen wenn im aktuellen Eintrag auch Stunden eingetragen sind
if ($row_verwendung->vertragsstunden != '')
{
if (isset($contracts['dv'][$dv]['vbs']))
{
foreach ($contracts['dv'][$dv]['vbs'] as $index_vbs=>$row_vbs)
{
if ($row_vbs['vertragsbestandteiltyp_kurzbz'] == 'stunden' || ($row_vbs['vertragsbestandteiltyp_kurzbz'] == 'karenz' && $row_verwendung->vertragsstunden === '0.00'))
{
if ($this->_isVBSAngrenzend($row_verwendung, $row_vbs) && ((isset($row_vbs['wochenstunden']) && $row_vbs['wochenstunden'] == $row_verwendung->vertragsstunden) || $row_verwendung->vertragsstunden === '0.00'))
{
// stunden bleiben gleich - Ende des VBS verlaengern
$contracts['dv'][$dv]['vbs'][$index_vbs]['bis'] = $row_verwendung->ende;
return true;
}
}
}
}
// kein passender VBS gefunden - neuen anlegen
$newVBSIndex = $this->_getNewVBSIndex($contracts, $dv);
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['vertragsbestandteiltyp_kurzbz'] = 'stunden';
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['von'] = $row_verwendung->beginn;
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['bis'] = $row_verwendung->ende;
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['wochenstunden'] = $row_verwendung->vertragsstunden;
$contracts['dv'][$dv]['vbs'][$newVBSIndex]['teilzeittyp_kurzbz'] = null;
}
return true;
}
/**
* Prueft ob die Verwendung direkt an den Vertragsbestandteil angrenzt
* @return boolean true wenn ja, sonst false
*/
private function _isVBSAngrenzend($verwendung, $vbs)
{
// Beginn Minus 1 Tag
$dtstart = new DateTime($verwendung->beginn);
$dtstartMinus1 = $dtstart->sub(new DateInterval('P1D'))->format('Y-m-d');
if ($vbs['bis'] == ''
|| $vbs['bis'] == $dtstartMinus1)
{
return true;
}
return false;
}
/**
* Create a new DV or Returns the Index of an existing
*/
private function _getOrCreateDV(&$contracts, $row_verwendung)
{
$unternehmen = $this->OE_DEFAULT;
$resultUnternehmen = $this->_getUnternehmen($row_verwendung);
if(hasData($resultUnternehmen))
{
$unternehmen = getData($resultUnternehmen)[0]->oe_kurzbz;
}
else
{
// Fallback Unternehmen wird verwendet falls keine Zuordnung ermittelt werden kann
}
if (isset($contracts['dv']) && is_array($contracts['dv']))
{
foreach($contracts['dv'] as $indexdv => $row_dv)
{
// Vertragsart ist die selbe und selbes Unternehmen
if ($row_dv['vertragsart_kurzbz'] == $this->matching_ba1_vertragsart[$row_verwendung->ba1code]
&& $row_dv['oe_kurzbz'] == $unternehmen
)
{
$dtstart = new DateTime($row_verwendung->beginn);
// Zeitraum passt zur Verwendung
if ($row_dv['von'] <= $row_verwendung->beginn // Beginn Datum Pruefen
&& ( // Ende innerhalb des DV
(isset($row_dv['bis']) && $row_verwendung->ende != '' && ($row_dv['bis'] == '' || $row_dv['bis'] >= $row_verwendung->ende)
)
|| // direkt angrenzend an dieses DV
(isset($row_dv['bis'])
&& ($row_dv['bis'] == ''
|| $row_dv['bis'] == $dtstart->sub(new DateInterval('P1D'))->format('Y-m-d')
)
)
)
)
{
return $indexdv;
}
}
}
}
$newDvIndex = $this->_getNewDVIndex($contracts);
$contracts['dv'][$newDvIndex]['mitarbeiter_uid'] = $row_verwendung->mitarbeiter_uid;
$contracts['dv'][$newDvIndex]['von'] = $row_verwendung->beginn;
$contracts['dv'][$newDvIndex]['bis'] = $row_verwendung->ende;
$contracts['dv'][$newDvIndex]['oe_kurzbz'] = $unternehmen;
$contracts['dv'][$newDvIndex]['vertragsart_kurzbz'] = $this->matching_ba1_vertragsart[$row_verwendung->ba1code];
return $newDvIndex;
}
/**
* Ermittelt in welchem Unternehmen die Person zum betreffenden Zeitpunkt ist.
*/
private function _getUnternehmen($row_verwendung)
{
$resultUnternehmen = $this->_findUnternehmen($row_verwendung->mitarbeiter_uid, "'kstzuordnung', 'oezuordnung'", $row_verwendung->beginn);
// Wenn zeitlich keine passende Unternehmenszuordnung vorhanden ist, dann suchen ob generell eine Zuordnung ermittelt werden kann
if(!hasData($resultUnternehmen))
{
$resultUnternehmen = $this->_findUnternehmen($row_verwendung->mitarbeiter_uid, "'kstzuordnung', 'oezuordnung'");
// Falls nicht wird nach erweiterten Funktionen gesucht um die Zuordnung zu ermitteln.
if(!hasData($resultUnternehmen))
{
$resultUnternehmen = $this->_findUnternehmen($row_verwendung->mitarbeiter_uid, "'kstzuordnung', 'oezuordnung','hilfskraft','Leitung','fbk','fbl'");
}
}
return $resultUnternehmen;
}
/**
* Detailsuche fuer die Ermittlung des Unternehmenszuordnung einer Person
*/
private function _findUnternehmen($uid, $fkt=null, $datum=null)
{
$db = new DB_Model();
$qry = "
WITH RECURSIVE meine_oes(oe_kurzbz, oe_parent_kurzbz, organisationseinheittyp_kurzbz) as
(
SELECT
oe_kurzbz, oe_parent_kurzbz, organisationseinheittyp_kurzbz
FROM
public.tbl_organisationseinheit
WHERE
oe_kurzbz=(SELECT
oe_kurzbz
FROM
public.tbl_benutzerfunktion
WHERE
uid=".$db->escape($uid);
if(!is_null($datum))
$qry.=" AND ".$db->escape($datum)." BETWEEN datum_von AND COALESCE(datum_bis, '2999-12-31')";
if(!is_null($fkt))
$qry.=" AND funktion_kurzbz in ($fkt)";
$qry.="
ORDER BY funktion_kurzbz, datum_von LIMIT 1)
UNION ALL
SELECT
o.oe_kurzbz, o.oe_parent_kurzbz, o.organisationseinheittyp_kurzbz
FROM
public.tbl_organisationseinheit o, meine_oes
WHERE
o.oe_kurzbz=meine_oes.oe_parent_kurzbz
)
SELECT
oe_kurzbz
FROM
meine_oes
WHERE
oe_parent_kurzbz is null
LIMIT 1
";
$resultUnternehmen = $db->execReadOnlyQuery($qry);
return $resultUnternehmen;
}
/**
* Ermittelt den nächsten (freien) Index für den Vertragsbetandteil
*/
private function _getNewVBSIndex($contracts, $dv)
{
if (isset($contracts['dv'][$dv]['vbs']))
return max(array_keys($contracts['dv'][$dv]['vbs'])) + 1;
else
return 0;
}
/**
* Ermittelt den nächsten (freien) Index für das Dienstverhältnis
*/
private function _getNewDVIndex($contracts)
{
if (isset($contracts['dv']) && is_array($contracts['dv']))
return max(array_keys($contracts['dv'])) + 1;
else
return 0;
}
/**
* Habilitation wird aus der Tabelle bis.tbl_bisverwendung in die Tabelle public.tbl_mitarbeiter uebernommen
* Sofern die Person einmal in den Verwendungen eine habiliation eingetragen hat wird diese in den MA-Datensatz übernommen
* Da es in der regel öfter vorkommt dass das hakerl vergessen wurde beim Vertragswechsel als dass die person die habiliation verliert.
*/
public function migrateHabilitation()
{
$this->load->model('ressource/Mitarbeiter_model','MitarbeiterModel');
$db = new DB_Model();
$qry = "
SELECT
distinct mitarbeiter_uid
FROM
bis.tbl_bisverwendung
WHERE
habilitation=true";
$resultHabilitation = $db->execReadOnlyQuery($qry);
if (isSuccess($resultHabilitation) && hasData($resultHabilitation))
{
$habilitationen = getData($resultHabilitation);
foreach ($habilitationen as $row_habilitationen)
{
$this->MitarbeiterModel->update($row_habilitationen->mitarbeiter_uid, array('habilitation'=>true));
}
}
}
}
@@ -1,188 +0,0 @@
<?php
if (! defined('BASEPATH')) exit('No direct script access allowed');
class MigrateHourlyRate extends CLI_Controller
{
CONST DEFAULT_OE = 'gst';
CONST DEFAULT_DATE = '1970-01-01';
CONST STUNDENSTAZTYP_LEHRE = 'lehre';
CONST STUNDENSTAZTYP_KALKULATORISCH = 'kalkulatorisch';
private $_ci;
public function __construct()
{
parent::__construct();
$this->_ci = & get_instance();
$this->load->model('codex/Bisverwendung_model', 'BisVerwendungModel');
$this->load->model('person/Benutzerfunktion_model', 'BenutzerfunktionModel');
$this->load->model('ressource/Stundensatz_model', 'StundensatzModel');
}
public function index($user = null)
{
$mitarbeiterResult = $this->_getMitarbeiterStunden($user);
if (isError($mitarbeiterResult)) return $mitarbeiterResult;
if (!hasData($mitarbeiterResult)) return error('Keine Mitarbeiterstunden gefunden');
$mitarbeiterArray = getData($mitarbeiterResult);
foreach ($mitarbeiterArray as $mitarbeiter)
{
$this->_getUnternehmen($mitarbeiter);
$insertResult = $this->_addStundensatz($mitarbeiter, self::STUNDENSTAZTYP_LEHRE, self::DEFAULT_DATE);
if (isError($insertResult)) return $insertResult;
}
$sapResult = $this->_getSapStunden($user);
if (isError($sapResult)) return $sapResult;
if (!hasData($sapResult)) return error('Keinen kalkulatorischen Stundensaetze gefunden');
$mitarbeiterArray = getData($sapResult);
foreach ($mitarbeiterArray as $mitarbeiter)
{
$this->_getUnternehmen($mitarbeiter);
$insertResult = $this->_addStundensatz($mitarbeiter, self::STUNDENSTAZTYP_KALKULATORISCH, date_format(date_create($mitarbeiter->beginn), 'Y-m-d'));
if (isError($insertResult)) return $insertResult;
}
}
private function _getSapStunden($user = null)
{
$dbModel = new DB_Model();
$params = array();
$qry = "SELECT ss.mitarbeiter_uid as uid,
ss.sap_kalkulatorischer_stundensatz as stundensatz,
ss.insertamum as beginn
FROM sync.tbl_sap_stundensatz ss
WHERE ss.sap_kalkulatorischer_stundensatz IS NOT NULL";
if (!is_null($user))
{
$qry .= " AND ss.mitarbeiter_uid = ? ";
$params[] = $user;
}
$qry .= " ORDER BY ss.mitarbeiter_uid";
return $dbModel->execReadOnlyQuery($qry, $params);
}
private function _getMitarbeiterStunden($user = null)
{
$dbModel = new DB_Model();
$params = array();
$qry = "SELECT mitarbeiter.mitarbeiter_uid as uid,
stundensatz
FROM public.tbl_mitarbeiter mitarbeiter
WHERE mitarbeiter.stundensatz != 0.00
AND mitarbeiter.stundensatz IS NOT NULL";
if (!is_null($user))
{
$qry .= " AND mitarbeiter.mitarbeiter_uid = ?";
$params[] = $user;
}
$qry .= " ORDER BY mitarbeiter.mitarbeiter_uid";
return $dbModel->execReadOnlyQuery($qry, $params);
}
private function _addStundensatz($mitarbeiter, $stundensatztyp, $gueltig_von)
{
return $this->_ci->StundensatzModel->insert(
array(
'uid' => $mitarbeiter->uid,
'stundensatztyp' => $stundensatztyp,
'stundensatz' => $mitarbeiter->stundensatz,
'oe_kurzbz' => $mitarbeiter->unternehmen,
'gueltig_von' => $gueltig_von,
'insertamum' => date('Y-m-d H:i:s'),
'insertvon' => 'MigrateHours'
)
);
}
private function _getUnternehmen(&$mitarbeiter)
{
$bvResult = $this->_ci->BisVerwendungModel->getLast($mitarbeiter->uid);
$beginn = null;
if (hasData($bvResult))
{
$beginn = getData($bvResult)[0]->beginn;
}
$unternehmenResult = $this->_findUnternehmen($mitarbeiter->uid, "'kstzuordnung', 'oezuordnung'", $beginn);
if(!hasData($unternehmenResult)) //&& hasData($bvResult)
{
$unternehmenResult = $this->_findUnternehmen($mitarbeiter->uid, "'kstzuordnung', 'oezuordnung'");
}
$unternehmen = self::DEFAULT_OE;
if (hasData($unternehmenResult))
$unternehmen = getData($unternehmenResult)[0]->oe_kurzbz;
$mitarbeiter->unternehmen = $unternehmen;
}
/**
* Detailsuche fuer die Ermittlung des Unternehmenszuordnung einer Person
*/
private function _findUnternehmen($uid, $fkt=null, $datum=null)
{
$dbModel = new DB_Model();
$qry = "
WITH RECURSIVE meine_oes(oe_kurzbz, oe_parent_kurzbz, organisationseinheittyp_kurzbz) as
(
SELECT
oe_kurzbz, oe_parent_kurzbz, organisationseinheittyp_kurzbz
FROM
public.tbl_organisationseinheit
WHERE
oe_kurzbz=(SELECT
oe_kurzbz
FROM
public.tbl_benutzerfunktion
WHERE
uid=".$dbModel->escape($uid);
if(!is_null($datum))
$qry.=" AND ".$dbModel->escape($datum)." BETWEEN datum_von AND COALESCE(datum_bis, '2999-12-31')";
if(!is_null($fkt))
$qry.=" AND funktion_kurzbz in ($fkt)";
$qry.="
ORDER BY funktion_kurzbz, datum_von LIMIT 1)
UNION ALL
SELECT
o.oe_kurzbz, o.oe_parent_kurzbz, o.organisationseinheittyp_kurzbz
FROM
public.tbl_organisationseinheit o, meine_oes
WHERE
o.oe_kurzbz=meine_oes.oe_parent_kurzbz
)
SELECT
oe_kurzbz
FROM
meine_oes
WHERE
oe_parent_kurzbz is null
LIMIT 1
";
return $dbModel->execReadOnlyQuery($qry);
}
}
@@ -1,495 +0,0 @@
<?php
/*
* Job zur einmaligen Import der Gehälter
*
* Aufruf (Encode / im Filenmae mit %2F):
* php index.ci.php system/MigrateSalary/import filename
*
*/
/*
AUFBAU CSV:
SVNR;Pers-Nr;Name;Dienstverhältnis;LA-Nr;Bezeichnung;2022-09-01;2022-10-01;2022-11-01;2022-12-01;2023-01-01;2023-02-01;2023-03-01
XXXX XXXXXX;00;Name;5;1000;Gehalt;1.111,10;1.211,10;1.311,10;1.411,10;1.511,10;1.611,10;1.711,10
*/
if (! defined('BASEPATH')) exit('No direct script access allowed');
class MigrateSalary extends CLI_Controller
{
private $OE_DEFAULT = 'gst';
private $GEHALT_BEGINN_SPALTE = 6; // Beginnend mit 0 => G
private $INDEX_LOHNART = 4;
private $INDEX_BEZEICHNUNG = 5;
/**
* Constructor
*/
public function __construct()
{
parent::__construct();
$this->load->model('vertragsbestandteil/Gehaltsbestandteil_model', 'GehaltsbestandteilModel');
$this->load->model('vertragsbestandteil/Dienstverhaeltnis_model','DienstverhaeltnisModel');
$this->load->model('vertragsbestandteil/Vertragsbestandteil_model','VertragsbestandteilModel');
$this->load->model('vertragsbestandteil/VertragsbestandteilStunden_model','VertragsbestandteilStundenModel');
$this->load->model('vertragsbestandteil/VertragsbestandteilFreitext_model','VertragsbestandteilFreitextModel');
$this->load->model('vertragsbestandteil/VertragsbestandteilFunktion_model','VertragsbestandteilFunktionModel');
}
// -----------------------------------------------------------------------------------------------------------------
// Public methods
/**
* Everything has a beginning
*/
public function import($file)
{
// CSV Laden
$file = urldecode($file);
if($handle = fopen($file, "r"))
{
$csvrow = -1;
$lastuser = '';
$monate = array();
$gehaltsarr = array();
$gehaltsindex = 0;
while (($data = fgetcsv($handle, null, ';')) !== FALSE)
{
$csvrow++;
// Kopfzeile ueberspringen
if($csvrow == 0)
{
for($i = $this->GEHALT_BEGINN_SPALTE; $i < count($data); $i++)
{
$monate[] = $data[$i];
}
continue;
}
// User zur SVNR ermitteln
$svnr = str_replace(' ', '',$data[0]);
$resultuser = $this->_getUser($svnr);
if(!hasData($resultuser))
{
echo getError($resultuser);
break;
}
$user = getData($resultuser)[0]->mitarbeiter_uid;
echo "\nUser:".$user;
if($user != $lastuser && $lastuser != '')
{
$this->_saveGehalt($lastuser, $gehaltsarr);
$gehaltsarr = array();
$gehaltsindex = 0;
$lastuser = $user;
}
else
{
$lastuser = $user;
}
// Gehalt Clustern
$monat = 0;
for ($i = $this->GEHALT_BEGINN_SPALTE; $i < count($data); $i++)
{
if (count($gehaltsarr) == 0 && $data[$i] != '')
{
$gehaltsarr[$gehaltsindex]['betrag'] = $data[$i];
$gehaltsarr[$gehaltsindex]['lohnart'] = $data[$this->INDEX_LOHNART];
$gehaltsarr[$gehaltsindex]['bezeichnung'] = $data[$this->INDEX_BEZEICHNUNG];
$gehaltsarr[$gehaltsindex]['beginn'] = $monate[$monat];
}
else
{
if ($data[$i] != ''
&& isset($gehaltsarr[$gehaltsindex]) && isset($gehaltsarr[$gehaltsindex]['betrag'])
&& $gehaltsarr[$gehaltsindex]['betrag'] == $data[$i])
{
// Gehalt bleibt gleich
}
else
{
if ($data[$i] != '')
{
// Gehalt hat sich geändert
if ($monat != 0 && isset($gehaltsarr[$gehaltsindex]))
$gehaltsarr[$gehaltsindex]['ende'] = $monate[$monat-1];
$gehaltsindex++;
$gehaltsarr[$gehaltsindex]['betrag'] = $data[$i];
$gehaltsarr[$gehaltsindex]['lohnart'] = $data[$this->INDEX_LOHNART];
$gehaltsarr[$gehaltsindex]['bezeichnung'] = $data[$this->INDEX_BEZEICHNUNG];
$gehaltsarr[$gehaltsindex]['beginn'] = $monate[$monat];
}
elseif(isset($gehaltsarr[$gehaltsindex]))
{
// Gehalt wurde beendet
if($monat!=0)
$gehaltsarr[$gehaltsindex]['ende'] = $monate[$monat-1];
$gehaltsindex++;
}
}
}
$monat++;
}
// Zeile zu Ende - Ende Datum setzen wenn nicht für alle Monate ein Eintrag vorhanden ist
if($monat < count($monate) && isset($gehaltsarr[$gehaltsindex]))
$gehaltsarr[$gehaltsindex]['ende'] = $monate[$monat-1];
}
$this->_saveGehalt($lastuser, $gehaltsarr);
}
}
/**
* Ermittelt das passende Dienstverhaeltnis uns speichert den
* Gehaltsbestandteil
*/
private function _saveGehalt($uid, $gehaltsarr)
{
$failed = false;
$this->db->trans_begin();
foreach($gehaltsarr as $row_gehalt)
{
//var_dump($row_gehalt);
$auszahlungen = 14;
$dvid = '';
$vbsid = '';
$typ = '';
$allin = false;
//DV und VBS Ermitteln
$dv = $this->DienstverhaeltnisModel->getDVByPersonUID($uid, $this->OE_DEFAULT, $row_gehalt['beginn']);
// Wenn keiner gefunden wird oder mit Monatsersteln nur ein externer gefunden wird, weitersuchen ob im Monat noch ein
// "richtiger" Vertrag startet
if (!hasData($dv) || getData($dv)[0]->vertragsart_kurzbz='externerLehrender')
{
$date = new DateTime($row_gehalt['beginn']);
$date->modify('last day of this month');
$last_day_this_month = $date->format('Y-m-d');
// Wenn mit Monatsersten kein DV gefunden wird, wird stattdessen mit Monatsletzten gesucht um DVs zu finden
// für Personen die erst später im Monat in ihr DV einsteigen
$dv = $this->DienstverhaeltnisModel->getDVByPersonUIDOverlapping($uid, $this->OE_DEFAULT, $row_gehalt['beginn'], $last_day_this_month);
if (!hasData($dv))
{
echo "\nKein passendes DV gefunden für User ".$uid." und Datum ".$row_gehalt['beginn']." -> ROLLBACK\n";
$failed = true;
break;
}
else
{
$resultdata = getData($dv);
foreach($resultdata as $dvdata)
{
// Externer DV wird in Monatsmitte zu echten DV - daher weitersuchen bei externenDVs da
// diese sowieso kein Gehalt zugeordnet haben
if($dvdata->vertragsart_kurzbz != 'externerLehrender')
{
$dvid = $dvdata->dienstverhaeltnis_id;
// Gehaltsstart wird auf den Start des DV korrigiert wenn nicht der Monatserste
// nur wenn das Beginndatum vor dem DV-Start liegt da sonst das Datum korrigiert wird
// wenn der Vertragsbestandteil wechselt
if($row_gehalt['beginn'] < $dvdata->von)
$row_gehalt['beginn'] = $dvdata->von;
break;
}
}
}
}
else
{
$resultdata = getData($dv);
if (count($resultdata) == 1)
$dvid = $resultdata[0]->dienstverhaeltnis_id;
}
if ($dvid == '')
{
echo "Kein oder mehrere DVs gefunden -> ROLLBACK";
$failed = true;
break;
}
$allin = $this->_isAllIn($dvid, $row_gehalt['beginn']);
$db = new DB_Model();
$resultVBS = $this->_getVBS($dvid, $row_gehalt['beginn']);
if (hasData($resultVBS))
{
$vbsid = getData($resultVBS)[0]->vertragsbestandteil_id;
$vbsbis = getData($resultVBS)[0]->bis;
}
else
{
echo "Vertragsbestandteil fuer $uid DV $dvid wurde nicht gefunden mit Beginn ".$row_gehalt['beginn']."-> ROLLBACK";
$failed = true;
break;
}
if ($row_gehalt['lohnart'] == 1000)
{
if($allin)
$typ = 'grundgehalt';
else
$typ = 'basisgehalt';
}
elseif ($row_gehalt['lohnart']==1041 // 14x
|| $row_gehalt['lohnart']==1042 // 12x
|| $row_gehalt['lohnart']==3410) // USTDPausch
{
$typ = 'zusatzvereinbarung';
// Freitextbestandteil anlegen fuer die Zulage
// Gaehalt wird der Zuglage zugeordnet
$data = array(
'dienstverhaeltnis_id' => $dvid,
'von' => $row_gehalt['beginn'],
'vertragsbestandteiltyp_kurzbz' => 'freitext',
'insertamum' => date('Y-m-d H:i:s'),
'insertvon' => 'MigrateSalary'
);
if (isset($row_gehalt['ende']) && $row_gehalt['ende']!='')
$data['bis'] = $row_gehalt['ende'];
$resultVBS = $this->VertragsbestandteilModel->Insert($data);
if(!isSuccess($resultVBS))
{
echo "VBS kann nicht erstellt werden -> ROLLBACK";
$failed = true;
break;
}
$vbsid = getData($resultVBS);
$data = array(
'vertragsbestandteil_id' => $vbsid,
'freitexttyp_kurzbz' => 'zusatzvereinbarung',
'titel' => $row_gehalt['bezeichnung'],
'anmerkung' => $row_gehalt['bezeichnung'],
);
$resultVBSFreitext = $this->VertragsbestandteilFreitextModel->Insert($data);
if(!isSuccess($resultVBSFreitext))
{
echo "VBS Freitext Zusatz kann nicht erstellt werden -> ROLLBACK";
$failed = true;
break;
}
}
elseif ($row_gehalt['lohnart']==9999) // All-In Custom Lohnart nicht per Default vorhanden
{
$typ = 'zulage';
// Freitextbestandteil anlegen fuer die Zulage
// Gaehalt wird der Zuglage zugeordnet
$data = array(
'dienstverhaeltnis_id' => $dvid,
'von' => $row_gehalt['beginn'],
'vertragsbestandteiltyp_kurzbz' => 'freitext',
'insertamum' => date('Y-m-d H:i:s'),
'insertvon' => 'MigrateSalary'
);
if (isset($row_gehalt['ende']) && $row_gehalt['ende']!='')
$data['bis'] = $row_gehalt['ende'];
$resultVBS = $this->VertragsbestandteilModel->Insert($data);
if(!isSuccess($resultVBS))
{
echo "VBS AllIn kann nicht erstellt werden -> ROLLBACK";
$failed = true;
break;
}
$vbsid = getData($resultVBS);
$data = array(
'vertragsbestandteil_id' => $vbsid,
'freitexttyp_kurzbz' => 'allin',
'titel' => $row_gehalt['bezeichnung'],
'anmerkung' => $row_gehalt['bezeichnung'],
);
$resultVBSFreitext = $this->VertragsbestandteilFreitextModel->Insert($data);
if(!isSuccess($resultVBSFreitext))
{
echo "VBS Freitext AllIn Zusatz kann nicht erstellt werden -> ROLLBACK";
$failed = true;
break;
}
}
elseif($row_gehalt['lohnart']==5500) // ATZ
{
$typ = 'lohnausgleichatz';
}
else
{
$typ = 'unbekannt - '.$row_gehalt['lohnart'];
echo "\nGehaltstyp unbekannt Lohnart: ".$row_gehalt['lohnart']." -> ROLLBACK";
$failed = true;
break;
}
// Zulage 12x und Zulage 14x aus der Bezeichnung ermitteln
if(strstr($row_gehalt['bezeichnung'], '12x'))
{
$auszahlungen = 12;
}
// Format ist 7.777,77 und wird umformattiert in 7777.77
$betrag = str_replace('.','', $row_gehalt['betrag']);
$betrag = str_replace(',','.',$betrag);
$data = array(
'dienstverhaeltnis_id' => $dvid,
'vertragsbestandteil_id' => $vbsid,
'gehaltstyp_kurzbz' => $typ,
'von' => $row_gehalt['beginn'],
'grundbetrag' => $betrag,
'betrag_valorisiert' => $betrag,
'anmerkung' => $row_gehalt['bezeichnung'],
'valorisierung' => true,
'auszahlungen' => $auszahlungen,
'insertamum' => date('Y-m-d H:i:s'),
'insertvon' => 'MigrateSalary',
'updateamum' => date('Y-m-d H:i:s'),
'updatevon' => 'MigrateSalary'
);
if (isset($row_gehalt['ende']) && $row_gehalt['ende'] != '')
{
// Im Ende steht noch der Monatserste des letzten Monats
// Das muss geaendert werden auf den Monatsletzten oder das Ende des DVs
$date = new DateTime($row_gehalt['ende']);
$date->modify('last day of this month');
$last_day_this_month = $date->format('Y-m-d');
// Wenn das Dienstverhaeltnis in diesem Monat endet und nicht der Monatsletzte ist,
// dann muss hier das Ende Datum des DV stehen bzw das Ende
// oder das Ende des VBS falls die Person in der Monatsmitte Stunden wechselt
$data['bis'] = $last_day_this_month;
// Wenn der Vertragsbestandteil endet bevor das Gehalt endet, dann wir das Gehaltsende auf VBS Ende gesetzt
//echo "Ende des VBS: $vbsbis Ende des Gehalt: ".$data['bis'];
if ($vbsbis != '' && $vbsbis < $data['bis'])
{
$data['bis'] = $vbsbis;
//echo "Gehalt auf vbs ende gesetzt";
}
}
$ret = $this->GehaltsbestandteilModel->insert($data,
$this->GehaltsbestandteilModel->getEncryptedColumns()
);
}
if(!$failed)
{
$this->db->trans_commit();
}
else
{
echo "ROLLBACK";
$this->db->trans_rollback();
}
}
/**
* Prueft ob ein AllIn Vertrag vorhanden ist
*/
private function _isAllIn($dvid, $datum)
{
$db = new DB_Model();
$qry = "
SELECT
*
FROM
hr.tbl_vertragsbestandteil
JOIN hr.tbl_vertragsbestandteil_freitext USING(vertragsbestandteil_id)
WHERE
dienstverhaeltnis_id=".$db->escape($dvid)."
AND vertragsbestandteiltyp_kurzbz='freitext'
AND ".$db->escape($datum)." BETWEEN von AND COALESCE(bis, '2999-12-31')
AND freitexttyp_kurzbz='allin'";
$resultAllIn = $db->execReadOnlyQuery($qry);
if (hasData($resultAllIn))
return true;
else
return false;
}
private function _getVBS($dvid, $datum)
{
$db = new DB_Model();
$qry = "
SELECT
*
FROM
hr.tbl_vertragsbestandteil
WHERE
dienstverhaeltnis_id=".$db->escape($dvid)."
AND vertragsbestandteiltyp_kurzbz='stunden'
AND ".$db->escape($datum)." BETWEEN von AND COALESCE(bis, '2999-12-31')";
$resultVBS = $db->execReadOnlyQuery($qry);
return $resultVBS;
}
/**
* Ermittelt den User zu einer SVNR
*/
private function _getUser($svnr)
{
$db = new DB_Model();
$qry = "
SELECT
mitarbeiter_uid
FROM
public.tbl_person
JOIN public.tbl_benutzer using(person_id)
JOIN public.tbl_mitarbeiter ON(uid=mitarbeiter_uid)
WHERE
tbl_person.svnr = ". $db->escape($svnr)."
AND EXISTS(
SELECT
1
FROM
hr.tbl_dienstverhaeltnis
WHERE
mitarbeiter_uid=tbl_mitarbeiter.mitarbeiter_uid
AND oe_kurzbz=". $db->escape($this->OE_DEFAULT)."
)
ORDER BY tbl_benutzer.aktiv DESC
LIMIT 1;
";
$result = $db->execReadOnlyQuery($qry);
if (hasdata($result))
{
return $result;
}
else
return error('Kein Benutzer mit DV und SVNR:'.$svnr.' gefunden');
}
}
@@ -1,32 +0,0 @@
<?php
if (! defined('BASEPATH')) exit('No direct script access allowed');
/**
* Test VBform Vue Component
*/
class TestVBform extends Auth_Controller
{
/**
* Constructor
*/
public function __construct()
{
parent::__construct(
array(
'index' => 'system/developer:r'
)
);
}
// -----------------------------------------------------------------------------------------------------------------
// Public methods
/**
* Everything has a beginning
*/
public function index()
{
$this->load->view('system/logs/testVBform.php');
}
}
@@ -21,7 +21,6 @@ class InfoCenter extends Auth_Controller
const FREIGEGEBEN_PAGE = 'freigegeben';
const REIHUNGSTESTABSOLVIERT_PAGE = 'reihungstestAbsolviert';
const ABGEWIESEN_PAGE = 'abgewiesen';
const AUFGENOMMEN_PAGE = 'aufgenommen';
const SHOW_DETAILS_PAGE = 'showDetails';
const SHOW_ZGV_DETAILS_PAGE = 'showZGVDetails';
const ZGV_UBERPRUEFUNG_PAGE = 'ZGVUeberpruefung';
@@ -116,7 +115,6 @@ class InfoCenter extends Auth_Controller
'index' => 'infocenter:r',
'freigegeben' => 'infocenter:r',
'abgewiesen' => 'infocenter:r',
'aufgenommen' => 'infocenter:r',
'reihungstestAbsolviert' => 'infocenter:r',
'showDetails' => 'infocenter:r',
'showZGVDetails' => 'lehre/zgvpruefung:r',
@@ -144,6 +142,12 @@ class InfoCenter extends Auth_Controller
'reloadNotizen' => array('infocenter:r', 'lehre/zgvpruefung:r'),
'reloadLogs' => 'infocenter:r',
'outputAkteContent' => array('infocenter:r', 'lehre/zgvpruefung:r'),
'getPostponeDate' => array('infocenter:r', 'lehre/zgvpruefung:r'),
'park' => 'infocenter:rw',
'unpark' => 'infocenter:rw',
'setOnHold' => 'infocenter:rw',
'removeOnHold' => array('infocenter:rw', 'lehre/zgvpruefung:rw'),
'getStudienjahrEnd' => array('infocenter:r', 'lehre/zgvpruefung:r'),
'setNavigationMenuArrayJson' => 'infocenter:r',
'getAbsageData' => 'infocenter:r',
'saveAbsageForAll' => 'infocenter:rw',
@@ -160,7 +164,6 @@ class InfoCenter extends Auth_Controller
$this->load->model('crm/Statusgrund_model', 'StatusgrundModel');
$this->load->model('crm/ZGVPruefung_model', 'ZGVPruefungModel');
$this->load->model('crm/ZGVPruefungStatus_model', 'ZGVPruefungStatusModel');
$this->load->model('crm/Rueckstellung_model', 'RueckstellungModel');
$this->load->model('person/Notiz_model', 'NotizModel');
$this->load->model('person/Person_model', 'PersonModel');
$this->load->model('system/Message_model', 'MessageModel');
@@ -230,16 +233,6 @@ class InfoCenter extends Auth_Controller
$this->load->view('system/infocenter/infocenterAbgewiesen.php');
}
/**
* Aufgenommene page of the InfoCenter tool
*/
public function aufgenommen()
{
$this->_setNavigationMenu(self::AUFGENOMMEN_PAGE); // define the navigation menu for this page
$this->load->view('system/infocenter/infocenterAufgenommen.php');
}
/**
*
@@ -326,7 +319,7 @@ class InfoCenter extends Auth_Controller
show_error('Person does not exist!');
$origin_page = $this->input->get(self::ORIGIN_PAGE);
if (in_array($origin_page, array(self::INDEX_PAGE, self::ABGEWIESEN_PAGE)))
if ($origin_page == self::INDEX_PAGE)
{
// mark person as locked for editing
$result = $this->PersonLockModel->lockPerson($person_id, $this->_uid, self::APP);
@@ -371,14 +364,7 @@ class InfoCenter extends Auth_Controller
if (isError($result)) show_error(getError($result));
$origin_page = $this->input->get(self::ORIGIN_PAGE);
if ($origin_page === self::ABGEWIESEN_PAGE)
$redirectLink = self::INFOCENTER_URI. '/' .self::ABGEWIESEN_PAGE;
else
$redirectLink = '/'.self::INFOCENTER_URI;
$redirectLink .= '?'.self::FHC_CONTROLLER_ID.'='.$this->getControllerId();
$redirectLink = '/'.self::INFOCENTER_URI.'?'.self::FHC_CONTROLLER_ID.'='.$this->getControllerId();
// Force reload of Dataset after Unlock
$redirectLink .= '&'.self::KEEP_TABLESORTER_FILTER.'=true';
@@ -620,7 +606,7 @@ class InfoCenter extends Auth_Controller
}
/**
* Sendet bei einer neuen ZGV Prüfung eine Mail an den Studiengang
* Sendet bei einer neuen ZGV Prüfung die Mail raus an den Studiengang
*/
private function sendZgvMail($mail, $typ, $person){
$data = array(
@@ -711,7 +697,7 @@ class InfoCenter extends Auth_Controller
/**
* Fügt einen neuen ZGV Status hinzu oder updated einen bestehenden
* Falls es erfolgreich war, wird eine Mail rausgeschickt
* Falls es erfolgreich war, sendet er die Mail raus
*/
public function zgvRueckfragen()
{
@@ -765,8 +751,7 @@ class InfoCenter extends Auth_Controller
$this->sendZgvMail($mail, $typ, $person);
elseif (isError($insert))
$this->terminateWithJsonError('Fehler beim Speichern');
}
else
}else
{
$insert = $this->ZGVPruefungModel->insert(
array(
@@ -796,7 +781,7 @@ class InfoCenter extends Auth_Controller
}
$hold = false;
if (hasData($this->RueckstellungModel->getByPersonId($person_id, 'onhold_zgv')))
if ($this->personloglib->getOnHoldDate($person_id) !== null)
$hold = true;
$this->outputJsonSuccess(
@@ -1177,7 +1162,107 @@ class InfoCenter extends Auth_Controller
->set_output($aktecontent->retval)
->_display();
}
/**
* Gets the date until which a person is parked
* @param $person_id
*/
public function getPostponeDate($person_id)
{
$result = array(
'type' => null,
'date' => null
);
$parkedDate = $this->personloglib->getParkedDate($person_id);
if (isset($parkedDate))
{
$result['type'] = 'parked';
$result['date'] = $parkedDate;
}
else
{
$onholdDate = $this->personloglib->getOnHoldDate($person_id);
if (isset($onholdDate))
{
$result['type'] = 'onhold';
$result['date'] = $onholdDate;
}
}
$this->outputJsonSuccess($result);
}
/**
* Initializes parking of a person, i.e. a person is not expected to do any actions while parked
*/
public function park()
{
$person_id = $this->input->post('person_id');
$date = $this->input->post('parkdate');
$result = $this->personloglib->park($person_id, date_format(date_create($date), 'Y-m-d'), self::TAETIGKEIT, self::APP, null, $this->_uid);
$this->outputJson($result);
}
/**
* Removes parking of a person
*/
public function unPark()
{
$person_id = $this->input->post('person_id');
$result = $this->personloglib->unPark($person_id);
$this->outputJson($result);
}
/**
* Sets a person on hold ("zurückstellen")
*/
public function setOnHold()
{
$person_id = $this->input->post('person_id');
$date = $this->input->post('onholddate');
$result = $this->personloglib->setOnHold($person_id, date_format(date_create($date), 'Y-m-d'), self::TAETIGKEIT, self::APP, null, $this->_uid);
$this->outputJson($result);
}
/**
* Removed on hold status of a person
*/
public function removeOnHold()
{
$person_id = $this->input->post('person_id');
$result = $this->personloglib->removeOnHold($person_id);
$this->outputJson($result);
}
/**
* Gets the End date of the current Studienjahr
*/
public function getStudienjahrEnd()
{
$this->load->model('organisation/studienjahr_model', 'StudienjahrModel');
$result = $this->StudienjahrModel->getCurrStudienjahr();
$json = null;
if (hasData($result))
{
$json = $result->retval[0]->ende;
}
$this->outputJsonSuccess(array($json));
}
/**
* Wrapper for setNavigationMenu, returns JSON message
@@ -1399,6 +1484,7 @@ class InfoCenter extends Auth_Controller
if($nachreichungAm < $today)
$this->terminateWithJsonError($this->p->t('infocenter', 'nachreichDatumNichtVergangenheit'));
$akte = $this->AkteModel->loadWhere(array('person_id' => $person_id, 'dokument_kurzbz' => $allowedTypes[$typ]));
if (hasData($akte)) {
@@ -1545,7 +1631,6 @@ class InfoCenter extends Auth_Controller
$freigegebenLink = site_url(self::INFOCENTER_URI.'/'.self::FREIGEGEBEN_PAGE);
$reihungstestAbsolviertLink = site_url(self::INFOCENTER_URI.'/'.self::REIHUNGSTESTABSOLVIERT_PAGE);
$abgewiesenLink = site_url(self::INFOCENTER_URI.'/'.self::ABGEWIESEN_PAGE);
$aufgenommenLink = site_url(self::INFOCENTER_URI.'/'.self::AUFGENOMMEN_PAGE);
$currentFilterId = $this->input->get(self::FILTER_ID);
if (isset($currentFilterId))
@@ -1553,7 +1638,6 @@ class InfoCenter extends Auth_Controller
$freigegebenLink .= '?'.self::PREV_FILTER_ID.'='.$currentFilterId;
$reihungstestAbsolviertLink .= '?'.self::PREV_FILTER_ID.'='.$currentFilterId;
$abgewiesenLink .= '?'.self::PREV_FILTER_ID.'='.$currentFilterId;
$aufgenommenLink .= '?'.self::PREV_FILTER_ID.'='.$currentFilterId;
}
$this->navigationlib->setSessionMenu(
@@ -1604,19 +1688,7 @@ class InfoCenter extends Auth_Controller
null, // subscriptLinkValue
'', // target
30 // sort
),
'aufgenommen' => $this->navigationlib->oneLevel(
'Aufgenommene', // description
$aufgenommenLink, // link
null, // children
'check', // icon
null, // subscriptDescription
false, // expand
null, // subscriptLinkClass
null, // subscriptLinkValue
'', // target
40 // sort
),
)
)
);
}
@@ -1644,9 +1716,6 @@ class InfoCenter extends Auth_Controller
if ($origin_page === self::ABGEWIESEN_PAGE)
$link = site_url(self::INFOCENTER_URI.'/'.self::ABGEWIESEN_PAGE);
if ($origin_page === self::AUFGENOMMEN_PAGE)
$link = site_url(self::INFOCENTER_URI.'/'.self::AUFGENOMMEN_PAGE);
$prevFilterId = $this->input->get(self::PREV_FILTER_ID);
if (isset($prevFilterId))
{
@@ -1,135 +0,0 @@
<?php
if (! defined('BASEPATH')) exit('No direct script access allowed');
class Rueckstellung extends Auth_Controller
{
private $_ci; // Code igniter instance
private $_uid;
public function __construct()
{
parent::__construct(
array(
'get' => array('infocenter:r', 'lehre/zgvpruefung:r'),
'set' => array('infocenter:r', 'lehre/zgvpruefung:r'),
'delete' => array('infocenter:r', 'lehre/zgvpruefung:r'),
'getStatus' => array('infocenter:rw', 'lehre/zgvpruefung:rw')
)
);
$this->load->model('crm/Rueckstellung_model', 'RueckstellungModel');
$this->load->model('crm/RueckstellungStatus_model', 'RueckstellungStatusModel');
$this->load->model('person/Person_model', 'PersonModel');
$this->load->library('PersonLogLib');
$this->_setAuthUID(); // sets property uid
$this->_ci =& get_instance(); // get code igniter instance
}
public function get($person_id)
{
$result = null;
$rueckstellung = $this->_ci->RueckstellungModel->getByPersonId($person_id);
if (isError($rueckstellung))
$this->terminateWithJsonError($this->_ci->p->t('ui', 'fehlerBeimLesen'));
if (hasData($rueckstellung))
{
$rueckstellung = getData($rueckstellung)[0];
$fullName = getData($this->_ci->PersonModel->getFullName($rueckstellung->insertvon));
$result = array(
'von' => $fullName,
'bezeichnung' => $rueckstellung->bezeichnung,
'bis' => $rueckstellung->datum_bis,
'status_kurzbz' => $rueckstellung->status_kurzbz
);
if ($rueckstellung->status_kurzbz === 'parked' && $rueckstellung->datum_bis < date('Y-m-d'))
{
$this->_ci->RueckstellungModel->delete(array('person_id' => $person_id, 'status_kurzbz' => 'parked'));
$result = null;
}
}
$this->outputJsonSuccess($result);
}
public function set()
{
$person_id = $this->input->post('person_id');
$datum_bis = $this->input->post('datum_bis');
$status_kurzbz = $this->input->post('status_kurzbz');
$result = $this->_ci->RueckstellungModel->insert(
array('person_id' => $person_id,
'status_kurzbz' => $status_kurzbz,
'datum_bis' => date_format(date_create($datum_bis), 'Y-m-d'),
'insertvon' => $this->_uid
)
);
if (isError($result))
$this->terminateWithJsonError(getError($result));
$this->_log($person_id, $status_kurzbz);
$this->outputJson($result);
}
public function delete()
{
$person_id = $this->input->post('person_id');
$status = $this->input->post('status');
$result = $this->_ci->RueckstellungModel->delete(array('person_id' => $person_id, 'status_kurzbz' => $status));
if (isError($result))
$this->terminateWithJsonError($this->_ci->p->t('ui', 'fehlerBeimSpeichern'));
$this->outputJson($result);
}
public function getStatus($aktiv = true)
{
$this->_ci->RueckstellungStatusModel->addOrder('sort');
$result = $this->_ci->RueckstellungStatusModel->loadWhere(array('aktiv' => $aktiv));
if (isError($result))
$this->terminateWithJsonError($this->_ci->p->t('ui', 'fehlerBeimLesen'));
$this->outputJsonSuccess(getData($result));
}
/**
* Retrieve the UID of the logged user and checks if it is valid
*/
private function _setAuthUID()
{
$this->_uid = getAuthUID();
if (!$this->_uid) show_error('User authentification failed');
}
private function _log($person_id, $status_kurzbz)
{
$message = "Person $person_id set to $status_kurzbz";
$this->_ci->personloglib->log(
$person_id,
'Action',
array(
'name' => 'Person status set',
'message' => $message,
'success' => true
),
'bewerbung',
'infocenter',
null,
$this->_uid
);
}
}
@@ -26,7 +26,6 @@ class Issues extends Auth_Controller
// Load models
$this->load->model('person/Benutzerfunktion_model', 'BenutzerfunktionModel');
$this->load->model('organisation/Organisationseinheit_model', 'OrganisationseinheitModel');
$this->load->model('system/Sprache_model', 'SpracheModel');
$this->loadPhrases(
array(
@@ -46,11 +45,10 @@ class Issues extends Auth_Controller
public function index()
{
$oes_for_issues = $this->_getOesForIssues();
$language_index = $this->_getLanguageIndex();
$this->load->view(
'system/issues/issues',
array_merge($oes_for_issues, array('language_index' => $language_index))
$oes_for_issues
);
}
@@ -168,28 +166,4 @@ class Issues extends Auth_Controller
'all_oe_kurzbz_berechtigt' => $all_oe_kurzbz_berechtigt
);
}
/**
* Gets language index of currently logged in user.
* @return object int (the index, start at 1)
*/
private function _getLanguageIndex()
{
$idx = 1;
$this->SpracheModel->addSelect('sprache, index');
$langRes = $this->SpracheModel->load();
if (hasData($langRes))
{
$userLang = getUserLanguage();
$lang = getData($langRes);
foreach ($lang as $l)
{
if ($l->sprache == $userLang) $idx = $l->index;
}
}
return $idx;
}
}
@@ -1,305 +0,0 @@
<?php
if (! defined('BASEPATH')) exit('No direct script access allowed');
class IssuesKonfiguration extends Auth_Controller
{
private $_uid;
const STRING_DATA_TYPE = 'string';
const INTEGER_DATA_TYPE = 'integer';
const FLOAT_DATA_TYPE = 'float';
public function __construct()
{
parent::__construct(
array(
'index' => 'admin:r',
'getApps' => 'admin:r',
'getFehlerKonfigurationByApp' => 'admin:r',
'saveFehlerKonfiguration' => 'admin:rw',
'deleteKonfiguration' => 'admin:rw',
'deleteKonfigurationsWerte' => 'admin:rw'
)
);
// Load libraries
$this->load->library('IssuesLib');
$this->load->library('WidgetLib');
// Load models
$this->load->model('system/Fehlerkonfigurationstyp_model', 'FehlerkonfigurationstypModel');
$this->load->model('system/Fehlerkonfiguration_model', 'FehlerkonfigurationModel');
$this->loadPhrases(
array(
'global',
'ui',
'filter',
'fehlermonitoring'
)
);
$this->_setAuthUID(); // sets property uid
$this->setControllerId(); // sets the controller id
}
// -----------------------------------------------------------------------------------------------------------------
// Public methods
/**
* Load initial view.
*/
public function index()
{
$this->load->view("system/issues/issuesKonfiguration.php");
}
/**
* Loads all Apps to which Fehler exist.
*/
public function getApps()
{
$this->FehlerModel->addDistinct();
$this->FehlerModel->addSelect('app');
$this->FehlerModel->addJoin('system.tbl_fehler_konfigurationstyp', 'app');
$this->FehlerModel->addOrder('app');
$appRes = $this->FehlerModel->load();
$this->outputJson($appRes);
}
/**
* Gets all fehlercodes, optionally by app.
*/
public function getFehlerKonfigurationByApp()
{
$app = $this->input->get('app');
// get all Konfiguration types, optionally filtered by app
$this->FehlerkonfigurationstypModel->addSelect('konfigurationstyp_kurzbz, konfigurationsdatentyp, beschreibung');
$this->FehlerkonfigurationstypModel->addOrder('konfigurationstyp_kurzbz');
$konfRes = isEmptyString($app)
? $this->FehlerkonfigurationstypModel->load()
: $this->FehlerkonfigurationstypModel->loadWhere(array('app' => $app));
if (isError($konfRes)) $this->terminateWithJsonError($this->p->t('fehlermonitoring', 'fehlerFehlerKonfigurationLaden'));
// get all Fehler, optionally filtered by app
$params = array('fehlercode_extern' => null);
$this->FehlerModel->addSelect('fehlercode, fehler_kurzbz, fehlertyp_kurzbz, fehlertext');
$this->FehlerModel->addOrder('fehlercode');
if (!isEmptyString($app)) $params['app'] = $app;
$fehlerRes = $this->FehlerModel->loadWhere($params);
if (isError($fehlerRes)) $this->terminateWithJsonError($this->p->t('fehlermonitoring', 'fehlerFehlerLaden'));
// return object with retrieved data
$konfObj = new StdClass();
$konfObj->konfigurationstypen = array();
$konfObj->fehler = array();
if (hasData($konfRes)) $konfObj->konfigurationstypen = getData($konfRes);
if (hasData($fehlerRes)) $konfObj->fehler = getData($fehlerRes);
$this->outputJsonSuccess($konfObj);
}
/**
* Saves a Fehler configuration, inserts new configuration or updates existing.
* Checks if datatype of passed configuration is correct.
*/
public function saveFehlerKonfiguration()
{
$result = null;
$konfigurationstyp_kurzbz = $this->input->post('konfigurationstyp_kurzbz');
$fehlercode = $this->input->post('fehlercode');
$konfigurationsWert = $this->input->post('konfigurationsWert');
// check if all params passed
if (isEmptyString($konfigurationstyp_kurzbz)) $this->terminateWithJsonError($this->p->t('fehlermonitoring', 'ungueltigerKonfigurationstyp'));
if (isEmptyString($fehlercode)) $this->terminateWithJsonError($this->p->t('fehlermonitoring', 'fehlercodeFehlt'));
// separate by semicolon if multiple values passed
$konfigurationsWert = explode(';', $konfigurationsWert);
// check konfigurationswert
// get the expected data type
$dataType = self::STRING_DATA_TYPE;
$this->FehlerkonfigurationstypModel->addSelect('konfigurationsdatentyp');
$konfigtypRes = $this->FehlerkonfigurationstypModel->loadWhere(array('konfigurationstyp_kurzbz' => $konfigurationstyp_kurzbz));
if (hasData($konfigtypRes))
{
$konfigurationsdatentyp = getData($konfigtypRes)[0]->konfigurationsdatentyp;
foreach ($konfigurationsWert as $idx => $konfWert)
{
// check if data type correct
$valid = false;
switch ($konfigurationsdatentyp)
{
case self::INTEGER_DATA_TYPE:
$valid = (string)(int)$konfWert == $konfWert;
$konfigurationsWert[$idx] = (int) $konfWert;
break;
case self::FLOAT_DATA_TYPE:
$valid = (string)(float)$konfWert == $konfWert;
$konfigurationsWert[$idx] = (float) $konfWert;
break;
default:
$valid = is_string($konfWert) && preg_match('/^[A-Za-z0-9_]+$/', $konfWert);
}
if (!$valid) $this->terminateWithJsonError($this->p->t('fehlermonitoring', 'ungueltigerKonfigurationswert', array($konfigurationsdatentyp)));
}
}
// check if konfiguration already set for the fehlercode
$this->FehlerkonfigurationModel->addSelect('konfiguration');
$fehlerkonfigurationRes = $this->FehlerkonfigurationModel->loadWhere(
array(
'konfigurationstyp_kurzbz' => $konfigurationstyp_kurzbz,
'fehlercode' => $fehlercode
)
);
if (isError($fehlerkonfigurationRes)) $this->terminateWithJsonError($this->p->t('fehlermonitoring', 'fehlerFehlerKonfigurationLaden'));
// if konfiguration exists, update by add konfiguration values to existing
if (hasData($fehlerkonfigurationRes))
{
$fehlerkonfiguration = getData($fehlerkonfigurationRes);
$existingKonf = json_decode($fehlerkonfiguration[0]->konfiguration);
if (!$existingKonf) $this->terminateWithJsonError($this->p->t('fehlermonitoring', 'fehlerJsonDekodierung'));
if (!is_array($existingKonf)) $existingKonf = array($existingKonf);
$newKonf = json_encode(array_values(array_unique(array_merge($existingKonf, $konfigurationsWert))));
if (!$newKonf) $this->terminateWithJsonError("error when encoding JSON");
$result = $this->FehlerkonfigurationModel->update(
array('konfigurationstyp_kurzbz' => $konfigurationstyp_kurzbz, 'fehlercode' => $fehlercode),
array('konfiguration' => $newKonf, 'updateamum' => 'NOW()', 'updatevon' => $this->_uid)
);
}
else // if no konfiguration exists, add new konfiguration entry
{
$newKonf = json_encode($konfigurationsWert);
if (!$newKonf) $this->terminateWithJsonError("error when encoding JSON");
$result = $this->FehlerkonfigurationModel->insert(
array(
'konfigurationstyp_kurzbz' => $konfigurationstyp_kurzbz,
'fehlercode' => $fehlercode,
'konfiguration' => $newKonf,
'insertvon' => $this->_uid
)
);
}
// output result (insert or update)
$this->outputJson($result);
}
/**
* Deletes values of a Konfiguration.
*/
public function deleteKonfigurationsWerte()
{
$konfigurationstyp_kurzbz = $this->input->post('konfigurationstyp_kurzbz');
$fehlercode = $this->input->post('fehlercode');
$konfigurationsWert = $this->input->post('konfigurationsWert');
// check if Konfigurationstyp correctly passed
if (isEmptyString($konfigurationstyp_kurzbz)) $this->terminateWithJsonError($this->p->t('fehlermonitoring', 'ungueltigerKonfigurationstyp'));
// check if fehlercode correctly passed
if (isEmptyString($fehlercode)) $this->terminateWithJsonError($this->p->t('fehlermonitoring', 'fehlercodeFehlt'));
// separate by semicolon if multiple values passed
$konfigurationsWert = explode(';', $konfigurationsWert);
// check if konfiguration already set for the fehlercode
$this->FehlerkonfigurationModel->addSelect('konfiguration');
$fehlerkonfigurationRes = $this->FehlerkonfigurationModel->loadWhere(
array(
'konfigurationstyp_kurzbz' => $konfigurationstyp_kurzbz,
'fehlercode' => $fehlercode
)
);
if (!hasData($fehlerkonfigurationRes)) $this->terminateWithJsonError($this->p->t('fehlermonitoring', 'fehlerFehlerKonfigurationLaden'));
// if konfiguration exists, update values
if (hasData($fehlerkonfigurationRes))
{
$fehlerkonfiguration = getData($fehlerkonfigurationRes);
$existingKonf = json_decode($fehlerkonfiguration[0]->konfiguration);
if (!$existingKonf) $this->terminateWithJsonError($this->p->t('fehlermonitoring', 'fehlerJsonDekodierung'));
if (!is_array($existingKonf)) $existingKonf = array($existingKonf);
$newKonfArr = array_values(array_diff($existingKonf, $konfigurationsWert));
// if no konfiguration values left, delete whole entry
if (isEmptyArray($newKonfArr))
{
$this->outputJson(
$this->FehlerkonfigurationModel->delete(
array('konfigurationstyp_kurzbz' => $konfigurationstyp_kurzbz, 'fehlercode' => $fehlercode)
)
);
}
else
{
$newKonf = json_encode($newKonfArr);
if (!$newKonf) $this->terminateWithJsonError("error when encoding JSON");
// if there are still values, delete only part of the konfiguration
$this->outputJson(
$this->FehlerkonfigurationModel->update(
array('konfigurationstyp_kurzbz' => $konfigurationstyp_kurzbz, 'fehlercode' => $fehlercode),
array('konfiguration' => $newKonf, 'updateamum' => 'NOW()', 'updatevon' => $this->_uid)
)
);
}
}
}
/**
* Deletes a Konfiguration.
*/
public function deleteKonfiguration()
{
$konfigurationstyp_kurzbz = $this->input->post('konfigurationstyp_kurzbz');
$fehlercode = $this->input->post('fehlercode');
// check if Konfigurationstyp correctly passed
if (isEmptyString($konfigurationstyp_kurzbz)) $this->terminateWithJsonError($this->p->t('fehlermonitoring', 'ungueltigerKonfigurationstyp'));
// check if fehlercode correctly passed
if (isEmptyString($fehlercode)) $this->terminateWithJsonError($this->p->t('fehlermonitoring', 'fehlercodeFehlt'));
$this->outputJson(
$this->FehlerkonfigurationModel->delete(
array('konfigurationstyp_kurzbz' => $konfigurationstyp_kurzbz, 'fehlercode' => $fehlercode)
)
);
}
/**
* Retrieve the UID of the logged user and checks if it is valid
*/
private function _setAuthUID()
{
$this->_uid = getAuthUID();
if (!$this->_uid) show_error('User authentification failed');
}
}
@@ -26,6 +26,7 @@ class IssuesZustaendigkeiten extends Auth_Controller
// Load models
$this->load->model('organisation/Organisationseinheit_model', 'OrganisationseinheitModel');
$this->load->model('system/Fehler_model', 'FehlerModel');
$this->load->model('system/Fehler_model', 'FehlerModel');
$this->load->model('system/Fehlerzustaendigkeiten_model', 'FehlerzustaendigkeitenModel');
$this->loadPhrases(
@@ -69,7 +70,7 @@ class IssuesZustaendigkeiten extends Auth_Controller
{
$app = $this->input->get('app');
$this->FehlerModel->addSelect('fehlercode, fehler_kurzbz, fehlertext, fehlertyp_kurzbz, app');
//$this->FehlerModel->addSelect('fehlercode, fehler_kurzbz, fehlertext, fehlertyp_kurzbz');
$this->FehlerModel->addOrder('fehlercode');
$fehlerRes = isset($app) ? $this->FehlerModel->loadWhere(array('app' => $app)) : $this->FehlerModel->load();
@@ -4,8 +4,6 @@ if (! defined('BASEPATH')) exit('No direct script access allowed');
class Plausichecks extends Auth_Controller
{
const GENERIC_ISSUE_OCCURED_TEXT = 'Issue aufgetreten';
public function __construct()
{
parent::__construct(
@@ -16,8 +14,7 @@ class Plausichecks extends Auth_Controller
);
// Load libraries
$this->load->library('issues/PlausicheckProducerLib', array('app' => 'core'));
$this->load->library('issues/PlausicheckDefinitionLib');
$this->load->library('issues/PlausicheckProducerLib');
$this->load->library('WidgetLib');
// Load models
@@ -45,43 +42,18 @@ class Plausichecks extends Auth_Controller
$fehler_kurzbz = $this->input->get('fehler_kurzbz');
// issues array for passing issue texts
$allIssues = array();
$issueTexts = array();
// all fehler kurzbz which are going to be checked
$fehlerKurzbz = !isEmptyString($fehler_kurzbz) ? array($fehler_kurzbz) : $this->plausicheckdefinitionlib->getFehlerKurzbz();
$fehlerLibMappings = $this->plausicheckdefinitionlib->getFehlerLibMappings();
$fehlerKurzbz = !isEmptyString($fehler_kurzbz) ? array($fehler_kurzbz) : $this->plausicheckproducerlib->getFehlerKurzbz();
// set Studiengang to null if not passed
if (isEmptyString($studiengang_kz)) $studiengang_kz = null;
// get the data returned by Plausicheck
foreach ($fehlerKurzbz as $fehler_kurzbz)
{
// get Text and fehlercode of the Fehler
$this->FehlerModel->addSelect('fehlercode, fehlertext, fehlertyp_kurzbz');
$fehlerRes = $this->FehlerModel->loadWhere(array('fehler_kurzbz' => $fehler_kurzbz));
if (isError($fehlerRes)) $this->terminateWithJsonError(getError($fehlerRes));
// do not check error if no data
if (!hasData($fehlerRes)) continue;
// get the error data
$fehler = getData($fehlerRes)[0];
// initialize issue array
$allIssues[$fehler_kurzbz] = array('fehlercode' => $fehler->fehlercode, 'data' => array());
// get library name for producing issue
$libName = $fehlerLibMappings[$fehler_kurzbz];
// execute the check
$plausicheckRes = $this->plausicheckproducerlib->producePlausicheckIssue(
$libName,
$fehler_kurzbz,
array(
'studiensemester_kurzbz' => $studiensemester_kurzbz,
'studiengang_kz' => $studiengang_kz
)
);
$issueTexts[$fehler_kurzbz] = array();
$plausicheckRes = $this->plausicheckproducerlib->producePlausicheckIssue($fehler_kurzbz, $studiensemester_kurzbz, $studiengang_kz);
if (isError($plausicheckRes)) $this->terminateWithJsonError(getError($plausicheckRes));
@@ -95,17 +67,21 @@ class Plausichecks extends Auth_Controller
$person_id = isset($plausiData['person_id']) ? $plausiData['person_id'] : null;
$oe_kurzbz = isset($plausiData['oe_kurzbz']) ? $plausiData['oe_kurzbz'] : null;
$fehlertext_params = isset($plausiData['fehlertext_params']) ? $plausiData['fehlertext_params'] : null;
$resolution_params = isset($plausiData['resolution_params']) ? $plausiData['resolution_params'] : null;
// get Text of the Fehler
$this->FehlerModel->addSelect('fehlertext');
$fehlerRes = $this->FehlerModel->loadWhere(array('fehler_kurzbz' => $fehler_kurzbz));
if (isError($fehlerRes)) $this->outputJsonError(getError($fehlerRes));
// optionally replace fehler parameters in text, output the fehlertext
if (!isEmptyString($fehler->fehlertext))
if (hasData($fehlerRes))
{
$fehlercode = $fehler->fehlercode;
$fehlerText = $fehler->fehlertext;
$fehlerTyp = $fehler->fehlertyp_kurzbz;
$fehlerText = getData($fehlerRes)[0]->fehlertext;
if (!isEmptyArray($fehlertext_params))
{
// replace placeholder with params, if present
if (count($fehlertext_params) != substr_count($fehlerText, '%s'))
$this->terminateWithJsonError('Wrong number of parameters for Fehlertext, fehler_kurzbz ' . $fehler_kurzbz);
@@ -114,25 +90,13 @@ class Plausichecks extends Auth_Controller
if (isset($person_id)) $fehlerText .= "; person_id: $person_id";
if (isset($oe_kurzbz)) $fehlerText .= "; oe_kurzbz: $oe_kurzbz";
$issueObj = new StdClass();
$issueObj->fehlertext = $fehlerText;
$issueObj->type = $fehlerTyp;
$allIssues[$fehler_kurzbz]['data'][] = $issueObj;
$issueTexts[$fehler_kurzbz][] = $fehlerText;
}
else // if no issue text found, use generic text
{
$fehlerText = self::GENERIC_ISSUE_OCCURED_TEXT;
}
// add generic parameters to issue text
if (isset($person_id)) $fehlerText .= "; person_id: $person_id";
if (isset($oe_kurzbz)) $fehlerText .= "; oe_kurzbz: $oe_kurzbz";
}
}
}
$this->outputJsonSuccess($allIssues);
$this->outputJsonSuccess($issueTexts);
}
/**
@@ -157,38 +121,13 @@ class Plausichecks extends Auth_Controller
if (isError($studiengaengeRes)) show_error(getError($studiengaengeRes));
$fehlerKurzbz = $this->plausicheckdefinitionlib->getFehlerKurzbz();
$db = new DB_Model();
// get fehlercodes for fehler_kurzbz
$fehlerRes = $db->execReadOnlyQuery(
'SELECT
fehler_kurzbz, fehlercode
FROM
system.tbl_fehler
WHERE
fehler_kurzbz IN ?',
array($fehlerKurzbz)
);
if (isError($fehlerRes)) show_error(getError($fehlerRes));
$fehlerKurzbzCodeMappings = array();
if (hasData($fehlerRes))
{
$fehler = getData($fehlerRes);
foreach ($fehler as $fe)
{
$fehlerKurzbzCodeMappings[$fe->fehler_kurzbz] = $fe->fehlercode;
}
}
$fehlerKurzbz = $this->plausicheckproducerlib->getFehlerKurzbz();
return array(
'semester' => hasData($studiensemesterRes) ? getData($studiensemesterRes) : array(),
'currsemester' => hasData($currSemRes) ? getData($currSemRes) : array(),
'studiengaenge' => hasData($studiengaengeRes) ? getData($studiengaengeRes) : array(),
'fehlerKurzbzCodeMappings' => $fehlerKurzbzCodeMappings
'fehler' => $fehlerKurzbz
);
}
}
@@ -37,7 +37,7 @@ class FASMessages extends Auth_Controller
// Loads the view to write a new message with a template
$this->load->view(
'system/messages/FAShtmlWriteTemplate',
'system/messages/htmlWriteTemplate',
$this->CLMessagesModel->prepareHtmlWriteTemplatePrestudents($prestudents)
);
}
@@ -53,7 +53,7 @@ class FASMessages extends Auth_Controller
// Loads the view to write a new message with a template
$this->load->view(
'system/messages/FAShtmlWriteTemplate',
'system/messages/htmlWriteTemplate',
$this->CLMessagesModel->prepareHtmlWriteTemplatePrestudents($prestudents, $message_id, $recipient_id)
);
}
-51
View File
@@ -1,51 +0,0 @@
<?php
if (! defined('BASEPATH')) exit('No direct script access allowed');
class CI3_Events
{
const PRIORITY_LOW = 200;
const PRIORITY_NORMAL = 100;
const PRIORITY_HIGH = 10;
private static $events = [];
private static $eventsSorted = [];
public static function on($event, $function, $priority = self::PRIORITY_NORMAL)
{
if (!isset(self::$events[$event]))
self::$events[$event] = [];
self::$events[$event][] = [$priority, $function];
if (!isset(self::$eventsSorted[$event]))
self::$eventsSorted[$event] = true;
else
self::$eventsSorted[$event] = false;
}
public static function trigger($event, ...$args)
{
if (!isset(self::$events[$event]))
return;
if (!self::$eventsSorted[$event]) {
usort(self::$events[$event], function ($a, $b) {
return $a[0] - $b[0];
});
self::$eventsSorted[$event] = true;
}
foreach (self::$events[$event] as $conf) {
$conf[1](...$args);
}
}
}
/**
* NOTE(chris): Autoload Events config
*/
require_once(APPPATH.'config/Events.php');
foreach (scandir(APPPATH.'config/extensions') as $dir)
if ($dir[0] != '.' && file_exists(APPPATH.'config/extensions/'.$dir.'/Events.php'))
require_once APPPATH.'config/extensions/'.$dir.'/Events.php';
+27 -296
View File
@@ -1,24 +1,5 @@
<?php
/**
* Copyright (C) 2023 fhcomplete.org
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
use \stdClass as stdClass;
if (!defined('BASEPATH')) exit('No direct script access allowed');
/**
@@ -46,15 +27,6 @@ class DB_Model extends CI_Model
const PGSQL_INT8_TYPE = 'int8';
const PGSQL_FLOAT4_TYPE = 'float4';
const PGSQL_FLOAT8_TYPE = 'float8';
const PGSQL_BYTEA_TYPE = 'bytea';
// Name of the config entry containing an array of password that can be used to encrypt/decrypt
const CRYPT_CONF_PASSWORDS = 'encryption_passwords';
const CRYPT_CAST = 'cast';
const CRYPT_PASSWORD_NAME = 'passwordName';
const CRYPT_SELECT_TEMPLATE = 'PGP_SYM_DECRYPT(%s, \'%s\')::%s AS %s';
const CRYPT_WHERE_TEMPLATE = 'PGP_SYM_DECRYPT(%s, \'%s\')::%s';
const CRYPT_WRITE_TEMPLATE = 'PGP_SYM_ENCRYPT(\'%s\', \'%s\')';
protected $dbTable; // Name of the DB-Table for CI-Insert, -Update, ...
protected $pk; // Name of the PrimaryKey for DB-Update, Load, ...
@@ -64,7 +36,7 @@ class DB_Model extends CI_Model
private $executedQueryMetaData;
private $executedQueryListFields;
private $debugMode; // Debug mode enable (true) or disabled (false)
private $debugMode;
/**
* Constructor
@@ -74,23 +46,20 @@ class DB_Model extends CI_Model
// Call parent constructor
parent::__construct();
// Loads DB connections and configs
$this->load->database($dbtype);
// Loads the DB config to encrypt/decrypt data
$this->config->load('db_crypt');
// Set properties
$this->hasSequence = true;
$this->debugMode = isset($this->db->db_debug) && $this->db->db_debug === true;
// Loads UDF model
// Loads DB conns and confs
$this->load->database($dbtype);
$this->load->model('system/UDF_model', 'UDFModel');
// Loads the UDF library
$this->load->library('UDFLib');
// Loads the logs library
$this->load->library('LogLib');
$this->debugMode = isset($this->db->db_debug) && $this->db->db_debug === true;
}
// ------------------------------------------------------------------------------------------
@@ -116,20 +85,13 @@ class DB_Model extends CI_Model
* @param array $data DataArray for Insert
* @return array
*/
public function insert($data, $encryptedColumns = null)
public function insert($data)
{
// Check class properties
if (is_null($this->dbTable)) return error('The given database table name is not valid', EXIT_MODEL);
// If this table has UDF and the validation of them is ok
$validate = $this->_prepareUDFsWrite($data, $this->dbTable);
if (isError($validate)) return $validate;
// Add the pgp_sym_eccrypt postgresql function to the set clause if needed
$this->_addEncrypt($encryptedColumns, $data);
// Add the pgp_sym_eccrypt postgresql function to the set clause if needed
if (!empty($encryptedColumns)) $this->_addEncrypt($encryptedColumns, $data);
if (isError($validate = $this->_prepareUDFsWrite($data, $this->dbTable))) return $validate;
// DB-INSERT
$insert = $this->db->insert($this->dbTable, $data);
@@ -173,15 +135,14 @@ class DB_Model extends CI_Model
* @param array $data DataArray for Insert
* @return array
*/
public function update($id, $data, $encryptedColumns = null)
public function update($id, $data)
{
// Check class properties
if (is_null($this->pk)) return error('The given primary key is not valid', EXIT_MODEL);
if (is_null($this->dbTable)) return error('The given database table name is not valid', EXIT_MODEL);
// If this table has UDF and the validation of them is ok
$validate = $this->_prepareUDFsWrite($data, $this->dbTable, $id);
if (isError($validate)) return $validate;
if (isError($validate = $this->_prepareUDFsWrite($data, $this->dbTable, $id))) return $validate;
$tmpId = $id;
@@ -200,9 +161,6 @@ class DB_Model extends CI_Model
$this->db->where($tmpId);
// Add the pgp_sym_eccrypt postgresql function to the set clause if needed
$this->_addEncrypt($encryptedColumns, $data);
// DB-UPDATE
$update = $this->db->update($this->dbTable, $data);
@@ -266,7 +224,7 @@ class DB_Model extends CI_Model
* @param string $id ID (Primary Key) for SELECT ... WHERE
* @return array
*/
public function load($id = null, $encryptedColumns = null)
public function load($id = null)
{
// Check class properties
if (is_null($this->pk)) return error('The given primary key is not valid', EXIT_MODEL);
@@ -287,7 +245,7 @@ class DB_Model extends CI_Model
$tmpId = array($this->pk => $id);
}
return $this->loadWhere($tmpId, $encryptedColumns);
return $this->loadWhere($tmpId);
}
/**
@@ -295,14 +253,11 @@ class DB_Model extends CI_Model
*
* @return array
*/
public function loadWhere($where = null, $encryptedColumns = null)
public function loadWhere($where = null)
{
// Check class properties
if (is_null($this->dbTable)) return error('The given database table name is not valid', EXIT_MODEL);
// Add the pgp_sym_decrypt postgresql function to the select and where clause if needed
$this->_addDecryptLoad($encryptedColumns, $where);
// Execute query
$result = $this->db->get_where($this->dbTable, $where);
@@ -310,7 +265,7 @@ class DB_Model extends CI_Model
if ($result)
{
return success($this->_toPhp($result, $encryptedColumns));
return success($this->_toPhp($result));
}
else
{
@@ -348,8 +303,7 @@ class DB_Model extends CI_Model
// NOTE: $this->db->list_fields($tables[$t]) doesn't work if there are two tables with
// the same name in two different schemas, use this workaround
$fields = array();
$lstColumns = $this->_list_columns($schemaAndTable->schema, $schemaAndTable->table);
if (isSuccess($lstColumns))
if (isSuccess($lstColumns = $this->_list_columns($schemaAndTable->schema, $schemaAndTable->table)))
{
$fields = $lstColumns->retval;
}
@@ -427,8 +381,7 @@ class DB_Model extends CI_Model
$tmpFilteredArray = array_filter(get_object_vars($sideTableObj));
if (isset($tmpFilteredArray) && count($tmpFilteredArray) > 0)
{
$k = $this->_findMainTable($mainTableObj, $returnArray);
if ($k === false)
if (($k = $this->_findMainTable($mainTableObj, $returnArray)) === false)
{
$mainTableObj->{$sideTableProperty} = array($sideTableObj);
$returnArray[$returnArrayCounter++] = $mainTableObj;
@@ -805,13 +758,14 @@ class DB_Model extends CI_Model
/**
* Like execQuery, but it allows only to perform queries to read data
*/
public function execReadOnlyQuery($query, $parametersArray = null, $encryptedColumns = null)
public function execReadOnlyQuery($query, $parametersArray = null)
{
$result = error('You are allowed to run only query for reading data'); //
$cleanedQuery = trim(preg_replace('/\t|\n|\r|;/', '', $query)); //
//
if ((stripos($cleanedQuery, 'INSERT') > 0 || stripos($cleanedQuery, 'INSERT') == false)
if (
(stripos($cleanedQuery, 'INSERT') > 0 || stripos($cleanedQuery, 'INSERT') == false)
&& (stripos($cleanedQuery, 'UPDATE') > 0 || stripos($cleanedQuery, 'UPDATE') == false)
&& (stripos($cleanedQuery, 'CREATE') > 0 || stripos($cleanedQuery, 'CREATE') == false)
&& (stripos($cleanedQuery, 'DELETE') > 0 || stripos($cleanedQuery, 'DELETE') == false)
@@ -821,7 +775,7 @@ class DB_Model extends CI_Model
{
$queryToExec = str_replace(';', '', $query); //
$result = $this->execQuery($queryToExec, $parametersArray, $encryptedColumns);
$result = $this->execQuery($queryToExec, $parametersArray);
}
return $result;
@@ -836,16 +790,13 @@ class DB_Model extends CI_Model
* boolean if the query is of the write type (INSERT, UPDATE, DELETE...)
* array that represents DB data
*/
protected function execQuery($query, $parametersArray = null, $encryptedColumns = null)
protected function execQuery($query, $parametersArray = null)
{
$result = null;
// If the query is empty don't lose time
if (!isEmptyString($query))
{
// Add the pgp_sym_decrypt postgresql function to the given query
$this->_addDecryptQuery($encryptedColumns, $query);
// If there are parameters to bind to the query
if (is_array($parametersArray) && count($parametersArray) > 0)
{
@@ -861,7 +812,7 @@ class DB_Model extends CI_Model
// If no errors occurred
if ($resultDB)
{
$result = success($this->_toPhp($resultDB, $encryptedColumns));
$result = success($this->_toPhp($resultDB));
}
else
{
@@ -889,8 +840,7 @@ class DB_Model extends CI_Model
$result->schema = DB_Model::DEFAULT_SCHEMA;
// If a schema is specified
$pos = strpos($schemaAndTable, '.');
if ($pos !== false)
if (($pos = strpos($schemaAndTable, '.')) !== false)
{
$result->schema = substr($schemaAndTable, 0, $pos);
$result->table = substr($schemaAndTable, $pos + 1);
@@ -901,207 +851,6 @@ class DB_Model extends CI_Model
// ------------------------------------------------------------------------------------------
// Private methods
//
//
/**
* To add the pgp_sym_encrypt function to the set clause where needed
*/
private function _addEncrypt($encryptedColumns, &$data)
{
// If encryptedColumns is not defined then exit
if (isEmptyArray($encryptedColumns)) return;
$tmpData = array(); // Temporary array used to copy not encrypted columns
// For each column that is going to be inserted/updated
foreach ($data as $column => $value)
{
// If the current column is in the list of the columns to be encrypted
// and contains the password name element
if (array_key_exists($column, $encryptedColumns)
&& array_key_exists(self::CRYPT_PASSWORD_NAME, $encryptedColumns[$column]))
{
// Password to encrypt data
$cryptConfPasswords = $this->config->item(self::CRYPT_CONF_PASSWORDS);
$encryptionPassword = $cryptConfPasswords[$encryptedColumns[$column][self::CRYPT_PASSWORD_NAME]];
// Add the encrypted column to the set clause without escaping
$this->db->set(
$column,
sprintf(
self::CRYPT_WRITE_TEMPLATE,
$value,
$encryptionPassword
),
false // no escaping
);
}
else // otherwise copy this element as it is
{
$tmpData[$column] = $value;
}
}
$data = $tmpData; // this array does not contain encrypted columns
}
/**
* To add the pgp_sym_decrypt function to the given query
*/
private function _addDecryptQuery($encryptedColumns, &$query)
{
// If it is request to get encrypted columns
if (!isEmptyArray($encryptedColumns))
{
// For each requested encrypted column
foreach ($encryptedColumns as $encryptedColumn => $definition)
{
// If the requested encrypted column is well defined
if (!isEmptyArray($definition)
&& array_key_exists(self::CRYPT_CAST, $definition)
&& array_key_exists(self::CRYPT_PASSWORD_NAME, $definition))
{
// And if exists the wanted password to decrypt in the configs
if (array_key_exists($definition[self::CRYPT_PASSWORD_NAME], $this->config->item(self::CRYPT_CONF_PASSWORDS)))
{
// Password to decrypt data
$cryptConfPasswords = $this->config->item(self::CRYPT_CONF_PASSWORDS);
$decryptionPassword = $cryptConfPasswords[$definition[self::CRYPT_PASSWORD_NAME]];
// Find and replace all the occurrences of the provided encrypted columns
// with the postgresql decryption function
$query = str_replace(
$encryptedColumn,
sprintf(
self::CRYPT_WHERE_TEMPLATE,
$encryptedColumn,
$decryptionPassword,
$definition[self::CRYPT_CAST]
),
$query
);
}
}
}
}
}
/**
* To add the pgp_sym_decrypt function to the select and where clause where needed
*/
private function _addDecryptLoad($encryptedColumns, &$where)
{
// If it is request to get encrypted columns
if (!isEmptyArray($encryptedColumns))
{
// For each requested encrypted column
foreach ($encryptedColumns as $encryptedColumn => $definition)
{
// If the requested encrypted column is well defined
if (!isEmptyArray($definition)
&& array_key_exists(self::CRYPT_CAST, $definition)
&& array_key_exists(self::CRYPT_PASSWORD_NAME, $definition))
{
// And if exists the wanted password to decrypt in the configs
if (array_key_exists($definition[self::CRYPT_PASSWORD_NAME], $this->config->item(self::CRYPT_CONF_PASSWORDS)))
{
// Password to decrypt data
$cryptConfPasswords = $this->config->item(self::CRYPT_CONF_PASSWORDS);
$decryptionPassword = $cryptConfPasswords[$definition[self::CRYPT_PASSWORD_NAME]];
// -----------------------------------------
// SELECT
// Add to the select clause the column to be decrypted
// NOTE: this is going to override any previously added column with the same name
$this->addSelect(
sprintf(
self::CRYPT_SELECT_TEMPLATE,
$encryptedColumn,
$decryptionPassword,
$definition[self::CRYPT_CAST],
$encryptedColumn
)
);
// -----------------------------------------
// WHERE
// If the where parameter is a valid array
if (!isEmptyArray($where))
{
$tmpWhere = array();
// For each condition of the where clause
foreach ($where as $column => $condition)
{
$operator = null; // operator not found in the column name
// Custom operators with 2 chars
if (strpos($column, '>=') != false
|| strpos($column, '<=') != false
|| strpos($column, '!=') != false
|| strpos($column, '<>') != false
)
{
$operator = ' '.substr(trim($column), -2).' ';
}
// Custom operators with 1 chars
elseif (strpos($column, '>') != false
|| strpos($column, '<') != false
|| strpos($column, '=') != false
)
{
$operator = ' '.substr(trim($column), -1).' ';
}
else // default operator
{
$operator = ' = ';
}
// If the column from the where clause is the same from the encrypted columns definition
if (trim($column) == $encryptedColumn
|| ($operator != null && substr(trim($column), 0, strlen(trim($column)) - 2) == $encryptedColumn)
)
{
// Then rename the column using the postgresql decryption function
$tmpWhere[sprintf(
self::CRYPT_WHERE_TEMPLATE,
$encryptedColumn,
$decryptionPassword,
$definition[self::CRYPT_CAST]
).$operator] = $condition;
}
else // otherwise copy the column as it is
{
$tmpWhere[$column] = $condition;
}
}
$where = $tmpWhere; // replace with the new where
}
// Otherwise if the where parameter is a valid string
elseif (!isEmptyString($where))
{
// Find and replace all the occurrences of the provided encrypted columns
// with the postgresql decryption function
$where = str_replace(
$encryptedColumn,
sprintf(
self::CRYPT_WHERE_TEMPLATE,
$encryptedColumn,
$decryptionPassword,
$definition[self::CRYPT_CAST]
),
$where
);
}
}
}
}
}
}
/**
* Invalid ID
@@ -1128,11 +877,11 @@ class DB_Model extends CI_Model
{
if ($id != null)
{
$prepareUDFsWrite = $this->udflib->prepareUDFsWrite($data, $schemaAndTable, $this->_getUDFsNoPerms($id));
$prepareUDFsWrite = $this->udflib->prepareUDFsWrite($data, $this->dbTable, $this->_getUDFsNoPerms($id));
}
else
{
$prepareUDFsWrite = $this->udflib->prepareUDFsWrite($data, $schemaAndTable);
$prepareUDFsWrite = $this->udflib->prepareUDFsWrite($data, $this->dbTable);
}
}
@@ -1146,7 +895,7 @@ class DB_Model extends CI_Model
* - A FALSE value on failure
* - Otherwise an object filled with data on success
*/
private function _toPhp($result, $encryptedColumns = null)
private function _toPhp($result)
{
$udfs = false; // if UDFs are inside the given result set
$toPhp = $result; // if there is nothing to convert then return the result from DB
@@ -1162,9 +911,7 @@ class DB_Model extends CI_Model
// Looking for booleans, arrays and UDFs
foreach ($this->executedQueryMetaData as $eqmd)
{
// If array type, boolean type, numeric type
// Or bytea type
// Or UDF type
// If array type, boolean type OR a UDF
if (strpos($eqmd->type, DB_Model::PGSQL_ARRAY_TYPE) !== false
|| $eqmd->type == DB_Model::PGSQL_BOOLEAN_TYPE
|| $eqmd->type == DB_Model::PGSQL_INT2_TYPE
@@ -1172,7 +919,6 @@ class DB_Model extends CI_Model
|| $eqmd->type == DB_Model::PGSQL_INT8_TYPE
|| $eqmd->type == DB_Model::PGSQL_FLOAT4_TYPE
|| $eqmd->type == DB_Model::PGSQL_FLOAT8_TYPE
|| $eqmd->type == DB_Model::PGSQL_BYTEA_TYPE
|| $this->udflib->isUDFColumn($eqmd->name, $eqmd->type))
{
// If UDFs are inside this result set
@@ -1235,21 +981,6 @@ class DB_Model extends CI_Model
{
$resultElement->{$toBeConverted->name} = $this->pgFloatPhp($resultElement->{$toBeConverted->name});
}
// Byte A type
elseif ($toBeConverted->type == DB_Model::PGSQL_BYTEA_TYPE)
{
// If encrypted columns are defined
// and if the byte a column is defined as encrypted column
if (!isEmptyArray($encryptedColumns)
&& array_key_exists($toBeConverted->name, $encryptedColumns))
{
// keep the column
}
else // otherwise remove the column from the result
{
unset($resultElement->{$toBeConverted->name});
}
}
}
}
}
-255
View File
@@ -1,255 +0,0 @@
<?php
if (!defined('BASEPATH')) exit('No direct script access allowed');
/**
* Controller using JSON
*/
class FHCAPI_Controller extends FHC_Controller
{
/**
* Response status
* @see https://github.com/omniti-labs/jsend
*/
const STATUS_SUCCESS = 'success';
const STATUS_FAIL = 'fail';
const STATUS_ERROR = 'error';
/**
* Error types
*/
const ERROR_TYPE_PHP = 'php'; // TODO(chris): php types from severity?
const ERROR_TYPE_EXCEPTION = 'exception';
const ERROR_TYPE_GENERAL = 'general';
const ERROR_TYPE_404 = '404';
const ERROR_TYPE_DB = 'db';
const ERROR_TYPE_VALIDATION = 'validation';
/**
* Return Object
*
* @var array
*/
private $returnObj = [];
/**
* Constructor
*
* @param array $requiredPermissions
* @return void
*/
public function __construct($requiredPermissions = [])
{
if (is_cli())
show_404();
parent::__construct();
$this->config->set_item('error_views_path', VIEWPATH.'errors'.DIRECTORY_SEPARATOR.'json'.DIRECTORY_SEPARATOR);
global $g_result;
$g_result = $this;
ob_start(function ($content) {
$http_response_code = http_response_code();
// NOTE(chris): For security reasons 404 will be displayed the same everywhere
if ($http_response_code == REST_Controller::HTTP_NOT_FOUND)
return $content;
header('Content-Type: application/json; charset=utf-8');
if (!isset($this->returnObj['meta']) || !isset($this->returnObj['meta']['status'])) {
switch ($http_response_code) {
case 200:
$this->setStatus(self::STATUS_SUCCESS);
break;
case 400:
$this->setStatus(self::STATUS_FAIL);
break;
default:
$this->setStatus(self::STATUS_ERROR);
break;
}
}
#$this->returnObj['test'] = implode('/n', headers_list());
return json_encode($this->returnObj);
});
// Load libraries
$this->load->library('AuthLib');
$this->load->library('PermissionLib');
// Checks if the caller is allowed to access to this content
$this->_isAllowed($requiredPermissions);
// For JSON Requests (as opposed to multipart/form-data) get the $_POST variable from the input stream instead
if ($this->input->get_request_header('Content-Type', true) == 'application/json')
$_POST = json_decode($this->security->xss_clean($this->input->raw_input_stream), true);
elseif (isset($_POST['_jsondata'])) {
$_POST = array_merge($_POST, json_decode($_POST['_jsondata'], true));
unset($_POST['_jsondata']);
}
}
// ---------------------------------------------------------------
// Handle Output object
// ---------------------------------------------------------------
/**
* @param array $data
* @param string $type (optional)
* @return void
*/
public function addError($data, $type = null)
{
if (!isset($this->returnObj['errors']))
$this->returnObj['errors'] = [];
$error = [];
if (is_array($data)) {
if ($type == self::ERROR_TYPE_VALIDATION)
$error['messages'] = $data;
else
$error = $data;
} else {
$error['message'] = $data;
}
if ($type)
$error['type'] = $type;
$this->returnObj['errors'][] = $error;
}
/**
* @param mixed $data
* @return void
*/
public function setData($data)
{
$this->returnObj['data'] = $data;
}
/**
* @param string $status
* @return void
*/
public function setStatus($status)
{
if (!isset($this->returnObj['meta']))
$this->returnObj['meta'] = [];
$this->returnObj['meta']['status'] = $status;
}
// ---------------------------------------------------------------
// Handle Output object - Shortcut functions
// ---------------------------------------------------------------
/**
* @param array $errors
* @return void
*/
protected function terminateWithValidationErrors($errors)
{
$this->output->set_status_header(REST_Controller::HTTP_BAD_REQUEST);
$this->addError($errors, self::ERROR_TYPE_VALIDATION);
$this->setStatus(self::STATUS_FAIL);
exit(EXIT_ERROR);
}
/**
* @param mixed $data (optional)
* @return void
*/
protected function terminateWithSuccess($data = null)
{
$this->setData($data);
$this->setStatus(self::STATUS_SUCCESS);
exit;
}
/**
* @param array $error
* @param string $type (optional)
* @return void
*/
protected function terminateWithError($error, $type = null)
{
$this->output->set_status_header(REST_Controller::HTTP_INTERNAL_SERVER_ERROR);
$this->addError($error, $type);
$this->setStatus(self::STATUS_ERROR);
exit;
}
/**
* @param stdclass $result
* @param string $errortype
* @return void
*/
protected function checkForErrors($result, $errortype = self::ERROR_TYPE_GENERAL)
{
// TODO(chris): IMPLEMENT!
if (isError($result)) {
$this->terminateWithError(getError($result), $errortype);
}
return $result->retval;
}
// TODO(chris): complete list
// ---------------------------------------------------------------
// Security
// ---------------------------------------------------------------
/**
* 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
*
* @param array $requiredPermissions
* @return void
*/
protected function _isAllowed($requiredPermissions)
{
// Checks if this user is entitled to access to this content
if (!$this->permissionlib->isEntitled($requiredPermissions, $this->router->method))
{
$this->output->set_status_header(isLogged() ? REST_Controller::HTTP_FORBIDDEN : REST_Controller::HTTP_UNAUTHORIZED);
$this->addError([
'message' => 'You are not allowed to access to this content',
'controller' => $this->router->class,
'method' => $this->router->method,
'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>"
*
* @param array $requiredPermissions
* @param string $method
* @return void
*/
protected function _rpsToString($requiredPermissions, $method)
{
if (!isset($requiredPermissions[$method]))
return '';
if (!is_array($requiredPermissions[$method]))
return $requiredPermissions[$method];
return implode(', ', $requiredPermissions[$method]);
}
}
-24
View File
@@ -1,24 +0,0 @@
<?php
/**
* Copyright (C) 2023 fhcomplete.org
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
interface IEncryption
{
public function getEncryptedColumns(): array;
}
+21
View File
@@ -0,0 +1,21 @@
<?php
/**
* Interface defining method to implement for issue producer (from core and extensions)
*/
interface IIssueExistsChecker
{
/**
* Checks if an issue exists.
* @param array $params parameters needed for issue detection
* @return object with success(true) if issue exists, success(false) otherwise
*/
public function checkIfIssueExists($paramsForChecking);
/**
* Produces an issue.
* @param array $params parameters needed for issue detection
* @return object with success(true) if issue exists, success(false) otherwise
*/
//public function produceIssue($person_id, $oe_kurzbz, $paramsForProducing);
}
+5 -12
View File
@@ -6,9 +6,7 @@
abstract class IssueResolver_Controller extends JOB_Controller
{
const CI_PATH = 'application';
const CI_LIBRARY_FOLDER = 'libraries';
const EXTENSIONS_FOLDER = 'extensions';
const ISSUE_RESOLVERS_FOLDER = 'issues/resolvers';
const ISSUES_FOLDER = 'issues/resolvers';
const CHECK_ISSUE_RESOLVED_METHOD_NAME = 'checkIfIssueIsResolved';
protected $_codeLibMappings;
@@ -62,15 +60,10 @@ abstract class IssueResolver_Controller extends JOB_Controller
isset($issue->behebung_parameter) ? json_decode($issue->behebung_parameter, true) : array()
);
// if called from extension (extension name set), path includes extension names
$libRootPath = isset($this->_extensionName) ? self::EXTENSIONS_FOLDER . '/' . $this->_extensionName . '/' : '';
// path for loading issue library
$issuesLibPath = $libRootPath . self::ISSUE_RESOLVERS_FOLDER . '/';
// file path of library for check if file exists
$issuesLibFilePath = DOC_ROOT . self::CI_PATH
. '/' . $libRootPath . self::CI_LIBRARY_FOLDER . '/' . self::ISSUE_RESOLVERS_FOLDER . '/' . $libName . '.php';
// if called from extension (extension name set), path includes extension names, otherwise it is the core library folder
$libRootPath = isset($this->_extensionName) ? 'extensions/' . $this->_extensionName . '/' : '';
$issuesLibPath = $libRootPath . self::ISSUES_FOLDER . '/';
$issuesLibFilePath = DOC_ROOT . self::CI_PATH . '/' . $libRootPath . 'libraries/' . self::ISSUES_FOLDER . '/' . $libName . '.php';
// check if library file exists
if (!file_exists($issuesLibFilePath))
@@ -1,66 +0,0 @@
<?php
/**
* Job for producing Plausicheck issues
*/
abstract class PlausiIssueProducer_Controller extends JOB_Controller
{
protected $_fehlerLibMappings;
protected $_app;
public function __construct($app = null)
{
parent::__construct();
// pass extension name if calling from extension
$extensionName = isset($this->_extensionName) ? $this->_extensionName : null;
// load libraries
$this->load->library('issues/PlausicheckProducerLib', array('extensionName' => $extensionName, 'app' => $this->_app));
$this->load->library('IssuesLib');
}
protected function producePlausicheckIssues($params)
{
$this->logInfo("Plausicheck issue producer job started");
// get the data returned by Plausicheck
foreach ($this->_fehlerLibMappings as $fehler_kurzbz => $libName)
{
// execute the check
$this->logInfo("Checking " . $fehler_kurzbz . "...");
$plausicheckRes = $this->plausicheckproducerlib->producePlausicheckIssue(
$libName,
$fehler_kurzbz,
$params
);
if (isError($plausicheckRes)) $this->logError(getError($plausicheckRes));
if (hasData($plausicheckRes))
{
$plausicheckData = getData($plausicheckRes);
foreach ($plausicheckData as $plausiData)
{
// get the data needed for issue production
$person_id = isset($plausiData['person_id']) ? $plausiData['person_id'] : null;
$oe_kurzbz = isset($plausiData['oe_kurzbz']) ? $plausiData['oe_kurzbz'] : null;
$fehlertext_params = isset($plausiData['fehlertext_params']) ? $plausiData['fehlertext_params'] : null;
$resolution_params = isset($plausiData['resolution_params']) ? $plausiData['resolution_params'] : null;
// write the issue
$addIssueRes = $this->issueslib->addFhcIssue($fehler_kurzbz, $person_id, $oe_kurzbz, $fehlertext_params, $resolution_params);
// log if error, or log info if inserted new issue
if (isError($addIssueRes))
$this->logError(getError($addIssueRes));
elseif (hasData($addIssueRes) && is_integer(getData($addIssueRes)))
$this->logInfo("Plausicheck issue " . $fehler_kurzbz . " successfully produced, person_id: " . $person_id);
}
}
}
$this->logInfo("Plausicheck issue producer job stopped");
}
}
+1 -18
View File
@@ -18,8 +18,6 @@
if (! defined('BASEPATH')) exit('No direct script access allowed');
use \DateTime as DateTime;
// ------------------------------------------------------------------------
// Collection of utility functions for general purpose
// ------------------------------------------------------------------------
@@ -356,8 +354,7 @@ function sanitizeProblemChars($str)
'ss' => '/&szlig;/'
);
$tmp = preg_replace($acentos, array_keys($acentos), htmlentities($str, ENT_NOQUOTES | ENT_HTML5, $enc));
return html_entity_decode($tmp, ENT_NOQUOTES | ENT_HTML5, $enc);
return preg_replace($acentos, array_keys($acentos), htmlentities($str, ENT_NOQUOTES | ENT_HTML5, $enc));
}
/**
@@ -408,17 +405,3 @@ function findResource($path, $resource, $subdir = false, $extraDir = null)
return null;
}
/**
* check if String can be converted to a date
*/
function isValidDate($dateString)
{
try
{
return (new DateTime($dateString)) !== false;
}
catch(Exception $e)
{
return false;
}
}
+1 -2
View File
@@ -96,8 +96,7 @@ function generateJSDataStorageObject($indexPage, $calledPath, $calledMethod)
app_root: "'.APP_ROOT.'",
ci_router: "'.$indexPage.'",
called_path: "'.$calledPath.'",
called_method: "'.$calledMethod.'",
user_language: "'.$user_language.'"
called_method: "'.$calledMethod.'"
};';
$toPrint .= "\n";
$toPrint .= '</script>';
+17 -95
View File
@@ -37,30 +37,19 @@ class AnrechnungLib
* @param $lv_id
* @return StdClass
*/
public function getAntragData($prestudent_id, $studiensemester_kurzbz, $lv_id, $anrechnung_id = null)
public function getAntragData($prestudent_id, $studiensemester_kurzbz, $lv_id)
{
$antrag_data = new StdClass();
// Get students UID.
$uid = $this->ci->StudentModel->getUID($prestudent_id);
// If Anrechnung exists
if (is_numeric($anrechnung_id))
// Get lehrveranstaltung data. Break, if course is not assigned to student.
if(!$lv = getData($this->ci->LehrveranstaltungModel->getLvByStudent($uid, $studiensemester_kurzbz, $lv_id))[0])
{
// Just load LV by lv_id
$result = $this->ci->LehrveranstaltungModel->load($lv_id);
$lv = getData($result)[0];
show_error('You are not assigned to this course yet.');
}
// If Anrechnung not exists
else
{
// Load LV, but check if student is assigned to that LV. Break, if not.
if(!$lv = getData($this->ci->LehrveranstaltungModel->getLvByStudent($uid, $studiensemester_kurzbz, $lv_id))[0])
{
show_error('You are not assigned to this course yet.');
}
}
// Get the students personal data
if (!$person = getData($this->ci->PersonModel->getByUid($uid))[0])
{
@@ -174,8 +163,6 @@ class AnrechnungLib
$anrechnung_data->insertvon = '';
$anrechnung_data->studiensemester_kurzbz = '';
$anrechnung_data->empfehlung = '';
$anrechnung_data->begruendung_ects = '';
$anrechnung_data->begruendung_lvinhalt = '';
$anrechnung_data->status_kurzbz = '';
$anrechnung_data->status = getUserLanguage() == 'German' ? 'neu' : 'new';
$anrechnung_data->dokumentname = '';
@@ -287,21 +274,14 @@ class AnrechnungLib
if (hasData($result))
{
$empfehlung_data->empfehlungsanfrageAm = (new DateTime($result->retval[0]->insertamum))->format('d.m.Y');
// Get users who received request for recommendation
if($this->ci->config->item('fbl') === TRUE)
{
$res = $this->getLeitungOfLvOe($anrechnung_id);
}
else
{
$res = $this->getLectors($anrechnung_id);
}
if (!isEmptyArray($res))
{
$empfehlung_data->empfehlungsanfrageAn = implode(', ', array_column($res, 'fullname'));
}
// Get lectors who received request for recommendation
$lector_arr = self::getLectors($anrechnung_id);
if (!isEmptyArray($lector_arr))
{
$empfehlung_data->empfehlungsanfrageAn = implode(', ', array_column($lector_arr, 'fullname'));
}
}
if (is_null($anrechnung->empfehlung_anrechnung))
@@ -761,25 +741,6 @@ class AnrechnungLib
// Continue, if LV has no lector (there is no one to ask for recommendation)
return hasData($result) ? true : false;
}
/**
* Check if user is allowed to recommend Anrechnung.
*
* @param $anrechnung_id
* @return bool
*/
public function isEmpfehlungsberechtigt($anrechnung_id)
{
if($this->ci->config->item('fbl') === TRUE)
{
return true;
}
// Get lv-leitungen or, if not present, all lectors of lv.
$lector_arr = $this->getLectors($anrechnung_id);
// Return false if lv-leitung is present and user is not lv-leitung. Otherways return always true.
return in_array(getAuthUID(), array_column($lector_arr, 'uid'));
}
/**
* Get LV Leitung. If not present, get all LV lectors.
@@ -813,14 +774,11 @@ class AnrechnungLib
// Check if lv has LV-Leitung
$key = array_search(true, array_column($result, 'lvleiter'));
// If lv has 1 or more LV-Leitungen, keep only them
// If lv has LV-Leitung, keep only the one
if ($key !== false)
{
foreach ($result as $lector)
{
if ($lector->lvleiter) $lector_arr[]= $lector;
}
$lector_arr[]= $result[$key];
}
// ...otherwise keep all lectors
else
@@ -845,40 +803,6 @@ class AnrechnungLib
return $lector_arr;
}
/**
* Get Leitung of Lehrveranstaltungs-Organisationseinheit.
*
* @param $anrechnung_id
* @return false|mixed|null
*/
public function getLeitungOfLvOe($anrechnung_id)
{
$this->ci->AnrechnungModel->addSelect('lehrveranstaltung_id');
$result = $this->ci->AnrechnungModel->load($anrechnung_id);
$lehrveranstaltung_id = getData($result)[0]->lehrveranstaltung_id;
// Get Leitungen
$result = $this->ci->LehrveranstaltungModel->getLeitungOfLvOe($lehrveranstaltung_id);
if (!hasData($result))
{
return false;
}
$oeLeitung_arr = getData($result);
foreach ($oeLeitung_arr as $oeLeitung)
{
$oeLeitung->fullname = $oeLeitung->vorname. ' '. $oeLeitung->nachname;
}
// Now make the array unique
$oeLeitung_arr = array_unique($oeLeitung_arr, SORT_REGULAR);
return $oeLeitung_arr;
}
// Return an object with Anrechnungdata
private function _setAnrechnungDataObject($anrechnung)
{
@@ -896,8 +820,6 @@ class AnrechnungLib
$anrechnung_data->insertvon= $anrechnung->insertvon;
$anrechnung_data->studiensemester_kurzbz= $anrechnung->studiensemester_kurzbz;
$anrechnung_data->empfehlung= $anrechnung->empfehlung_anrechnung;
$anrechnung_data->begruendung_ects = $anrechnung->begruendung_ects;
$anrechnung_data->begruendung_lvinhalt = $anrechnung->begruendung_lvinhalt;
// Get last status_kurzbz
$result = $this->ci->AnrechnungModel->getLastAnrechnungstatus($anrechnung->anrechnung_id);
File diff suppressed because it is too large Load Diff
+4 -1
View File
@@ -551,7 +551,10 @@ class AuthLib
// Needed information
$this->_ci->PersonModel->addSelect('person_id, vorname, nachname, uid');
// Retrieves the uid if it is possible for active users
$this->_ci->PersonModel->addJoin('public.tbl_benutzer', 'person_id', 'LEFT');
$this->_ci->PersonModel->addJoin(
'(SELECT uid, person_id FROM public.tbl_benutzer WHERE aktiv = TRUE) tb', 'person_id',
'LEFT'
);
// Execute query with where clause
$personResult = $this->_ci->PersonModel->loadWhere($queryParamsArray);
-2
View File
@@ -595,8 +595,6 @@ class DmsLib
if (isError($insDmsResult)) return $insDmsResult;
$upload_data['dms_id'] = getData($insDmsResult);
if(isset($upload_data['file_type']) && !isset($dms['mimetype']))
$dms['mimetype'] = $upload_data['file_type'];
// Insert DMS version
$insVersionResult = $this->_ci->DmsVersionModel->insert(
-304
View File
@@ -1,304 +0,0 @@
<?php
/* Copyright (C) 2022 fhcomplete.net
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
*
*/
require_once(dirname(__FILE__).'/../../vendor/nategood/httpful/bootstrap.php');
use \ZipArchive as ZipArchive;
/**
* Simple client to convert documents using Docsbox
*/
class DocsboxLib
{
const ERROR = 1;
const SUCCESS = 0;
const STATUS_FINISHED = 'finished'; // Docsbox status when a document conversion ended
const STATUS_QUEUED = 'queued'; // Docsbox status when a file has been queued for the conversion
const STATUS_STARTED = 'started'; // Docsbox status when a file has started being worked
const STATUS_WORKING = 'working'; // Docsbox status when a file is being converted
const OUTPUT_FILENAME = 'out.zip.pdf'; // File name used by docsbox to save a converted document
const DEFAULT_FORMAT = 'pdf'; // Default supported format
// -------------------------------------------------------------------------------------------------
// Public static methods
/**
* Static method used to convert a document using a Docsbox installation (local/remote) over the network
* It return 0 on success and any other integer on error
* NOTE: currently format is not supported
*/
public static function convert($inputFileName, $outputFileName, $format)
{
// If a format has not been given
if (($format == null) || ($format != null && ctype_space($format) === true)) $format = self::DEFAULT_FORMAT;
// Posts the file to docsbox
$queueId = self::_postFile($inputFileName);
// If an error occurred
if ($queueId == null) return self::ERROR;
// Checks and waits if the file has been converted
$resultUrl = self::_checkConvertion($queueId);
// If an error occurred
if ($resultUrl == null) return self::ERROR;
// Download and rename the converted file
$downloaded = self::_downloadFile($resultUrl, $outputFileName);
// If an error occurred
if (!$downloaded) return self::ERROR;
return self::SUCCESS;
}
// -------------------------------------------------------------------------------------------------
// Private static methods
/**
* Posts the given file to a Docsboxserver and checks the response to return a valid queue id
* On failure it returns a null value
*/
private static function _postFile($inputFileName)
{
$queueId = null;
try
{
// Posts the given file and expects a response in JSON format
$postFileResponse = \Httpful\Request::post(DOCSBOX_SERVER.DOCSBOX_PATH_API)
->attach(array('file' => $inputFileName))
->expectsJson()
->send();
// Checks that:
// - the response is not empty
// - the reponse body has the property id
// - the property id is a valid string
// - the reponse body has the property status
// - docsbox queued the conversion of the posted file
if (is_object($postFileResponse)
&& isset($postFileResponse->body)
&& isset($postFileResponse->body->id)
&& $postFileResponse->body->id != '' && $postFileResponse->body->id != null
&& isset($postFileResponse->body->status)
&& $postFileResponse->body->status == self::STATUS_QUEUED)
{
$queueId = $postFileResponse->body->id;
}
else
{
// If docsbox refused to convert the posted file
if (isset($postFileResponse->body->status)
&& $postFileResponse->body->status != self::STATUS_QUEUED)
{
error_log(
'Docsbox did not queue the posted file. Returned status: '.
$postFileResponse->body->status
);
}
else // any other generic error
{
error_log(
'An error occurred while posting to docsbox. Response: '.
print_r($postFileResponse, 1)
);
}
}
}
catch(\Httpful\Exception\ConnectionErrorException $cee) // Httpful exception
{
error_log($cee->getMessage());
}
catch (Exception $e) // any other exception
{
error_log($e->getMessage());
}
return $queueId;
}
/**
* Check the status of the file convertion identified by the given queue element id
* A URL is returned with the path where it is possible to download the converted file
* If an error occurred then a null value is returned
*/
private static function _checkConvertion($queueId)
{
$resultUrl = null;
$startConvertionsTime = time(); // time when the file conversion has started
// Until a timeout has occurred
while (time() - $startConvertionsTime <= DOCSBOX_CONVERSION_TIMEOUT)
{
sleep(DOCSBOX_WAITING_SLEEP_TIME); // takes a nap on every round
try
{
// Calls the docsbox server to check the status of the
// file conversion using the provided queue id
// it expects a response in JSON format
$getStatusResponse = \Httpful\Request::get(DOCSBOX_SERVER.DOCSBOX_PATH_API.$queueId)
->expectsJson()
->send();
// Checks that:
// - the response is not empty
// - the reponse body has the property id
// - the property id is a valid string
// - the reponse body has the property status
// - docsbox is working the conversion of the posted file
if (is_object($getStatusResponse)
&& isset($getStatusResponse->body->id)
&& $getStatusResponse->body->id != '' && $getStatusResponse->body->id != null
&& isset($getStatusResponse->body->status))
{
// Checks that docsbox has finished working on the file conversion
// and that there is a valid resultUrl property
if ($getStatusResponse->body->status == self::STATUS_FINISHED
&& isset($getStatusResponse->body->result_url)
&& $getStatusResponse->body->result_url != ''
&& $getStatusResponse->body->result_url != null)
{
$resultUrl = $getStatusResponse->body->result_url;
break;
}
// Just started or still working on it
elseif ($getStatusResponse->body->status == self::STATUS_WORKING
|| $getStatusResponse->body->status == self::STATUS_STARTED)
{
// go on!
}
else // any other status is abnormal
{
error_log(
'Not valid status for queue element: '.$queueId.'. Response: '.
print_r($getStatusResponse, 1)
);
break; // interrupt the loop on error
}
}
else // if the response from the docsbox server is not valid
{
error_log(
'An error occurred while checking the docsbox activity. Response: '.
print_r($getStatusResponse, 1)
);
break; // interrupt the loop on error
}
}
catch(\Httpful\Exception\ConnectionErrorException $cee) // Httpful exception
{
error_log($cee->getMessage());
break; // interrupt the loop on error
}
catch (Exception $e) // any other exception
{
error_log($e->getMessage());
break; // interrupt the loop on error
}
}
return $resultUrl;
}
/**
* Download the converted file using the provided URL, unzip it, and renames it into the provided file name
*/
private static function _downloadFile($resultUrl, $outputFileName)
{
$downloaded = false; // pessimistic assumption
try
{
// Download the file
$getFileResponse = \Httpful\Request::get(DOCSBOX_SERVER.$resultUrl)->send();
// If the downloaded file content is valid and not empty
if (isset($getFileResponse->body)
&& $getFileResponse->body != null
&& $getFileResponse->body != '')
{
// Output directory where to unzip the downloaded zip file
$outputDirectory = dirname($outputFileName);
// The path and name of the downloaded zip file
$temporaryDownloadedZip = sys_get_temp_dir().'/'.basename($resultUrl);
// Write the file content into a temporary directory and file
if (file_put_contents($temporaryDownloadedZip, $getFileResponse->body) != false)
{
$zipArchive = new ZipArchive;
// Open and extract the dowloaded zip file into the directory of the output file
if ($zipArchive->open($temporaryDownloadedZip) === true
&& $zipArchive->extractTo($outputDirectory) === true
&& $zipArchive->close() === true)
{
// Opened, extracted and closed!
// Rename the extracted file to the given output file name
if (rename($outputDirectory.'/'.self::OUTPUT_FILENAME, $outputFileName))
{
$downloaded = true;
}
else
{
error_log(
'An error occurred while renaming the extracted file: '.
$outputDirectory.'/'.self::OUTPUT_FILENAME.' into: '.
$outputFileName
);
}
}
else
{
error_log(
'An error occurred while working the dowloaded zip file: '.
$temporaryDownloadedZip
);
}
}
else // if an error occurred while writing
{
error_log(
'An error occurred while writing the file content to: '.
$temporaryDownloadedZip
);
}
}
else // if the downloaded file is not valid
{
error_log(
'An error occurred while downloading the file from the docsbox server: '.
print_r($getFileResponse, 1)
);
}
}
catch(\Httpful\Exception\ConnectionErrorException $cee)
{
error_log($cee->getMessage());
}
catch (Exception $e)
{
error_log($e->getMessage());
}
return $downloaded;
}
}
+18 -48
View File
@@ -14,28 +14,20 @@ class DocumentLib
// Gets CI instance
$this->ci =& get_instance();
// Which document converter has to be used
if (defined('DOCSBOX_ENABLED') && DOCSBOX_ENABLED === true)
{
// Use docsbox!!
}
else
{
exec('unoconv --version', $ret_arr);
exec('unoconv --version', $ret_arr);
if(isset($ret_arr[0]))
if(isset($ret_arr[0]))
{
$hlp = explode(' ', $ret_arr[0]);
if(isset($hlp[1]))
{
$hlp = explode(' ', $ret_arr[0]);
if(isset($hlp[1]))
{
$this->unoconv_version = $hlp[1];
}
else
show_error('Could not get Unoconv Version');
$this->unoconv_version = $hlp[1];
}
else
show_error('Unoconv not found - Please install Unoconv');
show_error('Could not get Unoconv Version');
}
else
show_error('Unoconv not found - Please install Unoconv');
}
/**
@@ -65,16 +57,9 @@ class DocumentLib
case 'application/vnd.ms-word':
case 'application/vnd.oasis.opendocument.text':
case 'text/plain':
if (defined('DOCSBOX_ENABLED') && DOCSBOX_ENABLED === true)
{
// Use docsbox
}
else
{
// Unoconv Version 0.6 seems to fail on converting TXT Files
if ($this->unoconv_version == '0.6')
return error();
}
// Unoconv Version 0.6 seems to fail on converting TXT Files
if ($this->unoconv_version == '0.6')
return error();
$ret = $this->convert($filename, $outFile, 'pdf');
if(isSuccess($ret))
@@ -120,7 +105,6 @@ class DocumentLib
finfo_close($finfo);
$out = null;
exec($cmd, $out, $ret);
if ($ret != 0)
{
@@ -139,26 +123,13 @@ class DocumentLib
*/
public function convert($inFile, $outFile, $format)
{
$ret = 0;
if ($this->unoconv_version == '0.6')
$command = 'unoconv -f %1$s %3$s > %2$s';
else
$command = 'unoconv -f %s --output %s %s 2>&1';
$command = sprintf($command, $format, $outFile, $inFile);
// If it is set to use docsbox
if (defined('DOCSBOX_ENABLED') && DOCSBOX_ENABLED === true)
{
require_once(dirname(__FILE__).'/../application/libraries/DocsboxLib.php');
$ret = DocsboxLib::convert($inFile, $outFile, $format);
}
else // otherwise use unoconv
{
if ($this->unoconv_version == '0.6')
$command = 'unoconv -f %1$s %3$s > %2$s';
else
$command = 'unoconv -f %s --output %s %s 2>&1';
$command = sprintf($command, $format, $outFile, $inFile);
$out = null;
exec($command, $out, $ret);
}
exec($command, $out, $ret);
if ($ret != 0)
{
@@ -220,7 +191,6 @@ class DocumentLib
$cmd .= '/countspaces { [ exch { dup 32 ne { pop } if } forall ] length } bind def >> ';
$cmd .= 'setpagedevice viewJPEG"';
$out = null;
exec($cmd, $out, $ret);
if ($ret != 0)
{
+4 -17
View File
@@ -1,5 +1,4 @@
<?php
/**
* Copyright (C) 2022 fhcomplete.org
*
@@ -37,7 +36,6 @@ class FilterCmptLib
const SESSION_METADATA = 'datasetMetadata';
const SESSION_ROW_NUMBER = 'rowNumber';
const SESSION_TIMEOUT = 'sessionTimeout';
const SESSION_ENCRYPTED_COLUMNS = 'encryptedColumns';
// Session dataset elements
const SESSION_DATASET = 'dataset';
@@ -64,7 +62,6 @@ class FilterCmptLib
// ...to specify permissions that are needed to use this FilterCmpt
const REQUIRED_PERMISSIONS = 'requiredPermissions';
const ENCRYPTED_COLUMNS = 'encryptedColumns';
// ...stament to retrieve the dataset
const QUERY = 'query';
@@ -105,7 +102,6 @@ class FilterCmptLib
private $_filterKurzbz;
private $_query;
private $_requiredPermissions;
private $_encryptedColumns;
private $_reloadDataset;
private $_sessionTimeout;
@@ -508,12 +504,10 @@ class FilterCmptLib
$saveCustomFilter = true;
}
if ($saveCustomFilter === true)
if ($saveCustomFilter === true)
{
$this->_setSessionElement(
FilterCmptLib::SESSION_SIDE_MENU,
$this->_generateFilterMenu($this->_app, $this->_datasetName)
);
$this->_setSessionElement(FilterCmptLib::SESSION_SIDE_MENU,
$this->_generateFilterMenu($this->_app, $this->_datasetName));
}
return $saveCustomFilter;
@@ -723,7 +717,6 @@ class FilterCmptLib
$this->_filterKurzbz = null;
$this->_query = null;
$this->_requiredPermissions = null;
$this->_encryptedColumns = null;
$this->_reloadDataset = true; // by default the dataset is NOT cached in session
$this->_sessionTimeout = FilterCmptLib::SESSION_DEFAULT_TIMEOUT;
@@ -734,12 +727,6 @@ class FilterCmptLib
$this->_requiredPermissions = $filterCmptArray[FilterCmptLib::REQUIRED_PERMISSIONS];
}
// Retrieved the encrypted columns parameter if present
if (isset($filterCmptArray[FilterCmptLib::ENCRYPTED_COLUMNS]))
{
$this->_encryptedColumns = $filterCmptArray[FilterCmptLib::ENCRYPTED_COLUMNS];
}
// Parameters needed to retrieve univocally a filter from DB
if (isset($filterCmptArray[FilterCmptLib::APP]))
{
@@ -1142,7 +1129,7 @@ class FilterCmptLib
$this->_ci->load->model('system/Filters_model', 'FiltersModel');
// Execute the given SQL statement suppressing error messages
$dataset = @$this->_ci->FiltersModel->execReadOnlyQuery($datasetQuery, null, $this->_encryptedColumns);
$dataset = @$this->_ci->FiltersModel->execReadOnlyQuery($datasetQuery);
}
return $dataset;
+6 -27
View File
@@ -1,26 +1,7 @@
<?php
/**
* Copyright (C) 2023 fhcomplete.org
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
if (! defined('BASEPATH')) exit('No direct script access allowed');
use \stdClass as stdClass;
/**
* FilterWidget logic
*/
@@ -35,7 +16,6 @@ class FilterWidgetLib
const SESSION_SELECTED_FIELDS = 'selectedFields';
const SESSION_COLUMNS_ALIASES = 'columnsAliases';
const SESSION_ADDITIONAL_COLUMNS = 'additionalColumns';
const SESSION_ENCRYPTED_COLUMNS = 'encryptedColumns';
const SESSION_CHECKBOXES = 'checkboxes';
const SESSION_FILTERS = 'filters';
const SESSION_METADATA = 'datasetMetadata';
@@ -76,7 +56,6 @@ class FilterWidgetLib
const ADDITIONAL_COLUMNS = 'additionalColumns';
const CHECKBOXES = 'checkboxes';
const COLUMNS_ALIASES = 'columnsAliases';
const ENCRYPTED_COLUMNS = 'encryptedColumns';
// ...to format/mark records of a dataset
const FORMAT_ROW = 'formatRow';
@@ -141,7 +120,7 @@ class FilterWidgetLib
/**
* Gets the CI instance and loads message helper
*/
public function __construct()
public function __construct($params = null)
{
$this->_ci =& get_instance(); // get code igniter instance
}
@@ -388,7 +367,7 @@ class FilterWidgetLib
/**
* Retrieves the dataset from the DB
*/
public function getDataset($datasetQuery, $encryptedColumns)
public function getDataset($datasetQuery)
{
$dataset = null;
@@ -397,7 +376,7 @@ class FilterWidgetLib
$this->_ci->load->model('system/Filters_model', 'FiltersModel');
// Execute the given SQL statement suppressing error messages
$dataset = @$this->_ci->FiltersModel->execReadOnlyQuery($datasetQuery, null, $encryptedColumns);
$dataset = @$this->_ci->FiltersModel->execReadOnlyQuery($datasetQuery);
}
return $dataset;
@@ -411,7 +390,7 @@ class FilterWidgetLib
public function getFilterName($filterJson)
{
$filterName = $filterJson->name; // always present, used as default
$trimedname = (isset($filterJson->namePhrase)?trim($filterJson->namePhrase):'');
// Filter name from phrases system
if (isset($filterJson->namePhrase) && !isEmptyString($filterJson->namePhrase))
{
@@ -472,8 +451,7 @@ class FilterWidgetLib
if (in_array($selectedField, $fields))
{
// If the selected field is present in the list of the selected fields by the current filter
$pos = array_search($selectedField, $selectedFields);
if ($pos !== false)
if (($pos = array_search($selectedField, $selectedFields)) !== false)
{
// Then remove it and shift the rest of elements by one if needed
array_splice($selectedFields, $pos, 1);
@@ -772,6 +750,7 @@ class FilterWidgetLib
$this->_ci->load->library('NavigationLib', array(self::NAVIGATION_PAGE => $navigationPage));
$filterMenu = null;
$currentMenu = $this->_ci->navigationlib->getSessionMenu(); // The navigation menu currently stored in session
$session = $this->getSession(); // The filter currently stored in session (the one that is currently used)
if ($session != null)
-1
View File
@@ -182,7 +182,6 @@ class MailLib
{
if ($this->sended == $this->email_number_per_time_range)
{
$this->sended = 0;
sleep($this->email_time_range); // Wait!!!
}
}
+165
View File
@@ -7,6 +7,9 @@ if (! defined('BASEPATH')) exit('No direct script access allowed');
*/
class PersonLogLib
{
const PARKED_LOGNAME = 'Parked';
const ONHOLD_LOGNAME = 'Onhold';
/**
* Constructor
*/
@@ -75,6 +78,168 @@ class PersonLogLib
else
show_error(getError($result));
}
/**
* Parks a person, i.e. marks a person so no actions are expected for the person (e.g. as a prestudent)
* Done by adding a logentry in the future
* @param $person_id
* @param $date
* @param $taetigkeit_kurzbz
* @param string $app
* @param null $oe_kurzbz
* @param null $user
* @return insert object
*/
public function park($person_id, $date, $taetigkeit_kurzbz, $app = 'core', $oe_kurzbz = null, $user = null)
{
$onhold = $this->getOnHoldDate($person_id);
if (hasData($onhold))
return error("Person already on hold");
$logjson = array(
'name' => self::PARKED_LOGNAME
);
return $this->_savePsLog($person_id, $date, $taetigkeit_kurzbz, $logjson, $app, $oe_kurzbz, $user);
}
/**
* Unparks a person, i.e. removes all log entries in the future with logname for parking
* @param $person_id
* @return array with deleted logids
*/
public function unPark($person_id)
{
$deleted = array();
$result = $this->ci->PersonLogModel->getLogsInFuture($person_id);
if (hasData($result))
{
foreach ($result->retval as $log)
{
$logdata = json_decode($log->logdata);
if (isset($logdata->name) && $logdata->name === self::PARKED_LOGNAME)
{
$delresult = $this->ci->PersonLogModel->deleteLog($log->log_id);
if (isSuccess($delresult))
{
$deleted[] = $log->log_id;
}
}
}
}
return success($deleted);
}
/**
* Gets date until which a person is parked
* @param $person_id
* @return the date if person is parked, null otherwise
*/
public function getParkedDate($person_id)
{
$result = $this->ci->PersonLogModel->getLogsInFuture($person_id);
$parkeddate = null;
if (hasData($result))
{
foreach ($result->retval as $log)
{
$logdata = json_decode($log->logdata);
if (isset($logdata->name) && $logdata->name === self::PARKED_LOGNAME)
{
$parkeddate = $log->zeitpunkt;
break;
}
}
}
return $parkeddate;
}
/**
* Sets person on hold, i.e. marks a person so no actions are expected for the person (e.g. as a prestudent).
* Done by adding a logentry with a special name. can be undone only manually by clicking button.
* @param $person_id
* @param $date
* @param $taetigkeit_kurzbz
* @param string $app
* @param null $oe_kurzbz
* @param null $user
* @return array
*/
public function setOnHold($person_id, $date, $taetigkeit_kurzbz, $app = 'core', $oe_kurzbz = null, $user = null)
{
$parked = $this->getParkedDate($person_id);
if (hasData($parked))
return error("Person already parked");
$logjson = array(
'name' => self::ONHOLD_LOGNAME
);
return $this->_savePsLog($person_id, $date, $taetigkeit_kurzbz, $logjson, $app, $oe_kurzbz, $user);
}
/**
* Removes on hold status, i.e. removes all log entries with logname for on hold
* @param $person_id
* @return array
*/
public function removeOnHold($person_id)
{
$deleted = array();
$result = $this->ci->PersonLogModel->filterLog($person_id);
if (hasData($result))
{
foreach ($result->retval as $log)
{
$logdata = json_decode($log->logdata);
if (isset($logdata->name) && $logdata->name === self::ONHOLD_LOGNAME)
{
$delresult = $this->ci->PersonLogModel->deleteLog($log->log_id);
if (isSuccess($delresult))
{
$deleted[] = $log->log_id;
}
}
}
}
return success($deleted);
}
/**
* Gets date until which a person is on hold
* @param $person_id
* @return the date if person is on hold, null otherwise
*/
public function getOnHoldDate($person_id)
{
$result = $this->ci->PersonLogModel->filterLog($person_id);
$onholddate = null;
if (hasData($result))
{
foreach ($result->retval as $log)
{
$logdata = json_decode($log->logdata);
if (isset($logdata->name) && $logdata->name === self::ONHOLD_LOGNAME)
{
$onholddate = $log->zeitpunkt;
break;
}
}
}
return $onholddate;
}
/**
* Saves a processstate log with specified parameters, including a specified log date.
* @param $person_id
-412
View File
@@ -1,412 +0,0 @@
<?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');
class PrestudentLib
{
/**
* Object initialization
*/
public function __construct()
{
$this->_ci =& get_instance();
// // Configs
// $this->_ci->load->config('studierendenantrag');
// // Models
$this->_ci->load->model('crm/Prestudent_model', 'PrestudentModel');
$this->_ci->load->model('crm/Student_model', 'StudentModel');
$this->_ci->load->model('crm/Prestudentstatus_model', 'PrestudentstatusModel');
$this->_ci->load->model('education/Zeugnisnote_model', 'ZeugnisnoteModel');
$this->_ci->load->model('organisation/Lehrverband_model', 'LehrverbandModel');
$this->_ci->load->model('education/Studentlehrverband_model', 'StudentlehrverbandModel');
$this->_ci->load->model('person/Benutzer_model', 'BenutzerModel');
$this->_ci->load->model('organisation/Studiengang_model', 'StudiengangModel');
}
public function setAbbrecher($prestudent_id, $studiensemester_kurzbz, $insertvon = null, $statusgrund_kurzbz = null, $datum = null, $bestaetigtam = null, $bestaetigtvon = null)
{
if (!$insertvon)
$insertvon = getAuthUID();
if (!$bestaetigtvon)
$bestaetigtvon = $insertvon;
$result = $this->_ci->PrestudentstatusModel->getLastStatus($prestudent_id, $studiensemester_kurzbz);
if (isError($result))
return $result;
$result = getData($result);
if (!$result)
return error($this->_ci->p->t('studierendenantrag', 'error_no_prestudent_in_sem', [
'prestudent_id' => $prestudent_id,
'studiensemester_kurzbz' => $studiensemester_kurzbz
]));
$prestudent_status = current($result);
$result = $this->_ci->StudentModel->loadWhere(['prestudent_id' => $prestudent_id]);
if (isError($result))
return $result;
$result = getData($result);
if (!$result)
return error($this->_ci->p->t('studierendenantrag', 'error_no_student_for_prestudent', ['prestudent_id' => $prestudent_id]));
$student = current($result);
if(!$datum)
$datum = date('c');
if(!$bestaetigtam)
$bestaetigtam = date('c');
//Status und Statusgrund updaten
$result = $this->_ci->PrestudentstatusModel->withGrund($statusgrund_kurzbz)->insert([
'prestudent_id' => $prestudent_id,
'status_kurzbz' => Prestudentstatus_model::STATUS_ABBRECHER,
'studiensemester_kurzbz' => $prestudent_status->studiensemester_kurzbz,
'ausbildungssemester' => $prestudent_status->ausbildungssemester,
'datum' => $datum,
'insertvon' => $insertvon,
'insertamum' => date('c'),
'orgform_kurzbz'=> $prestudent_status->orgform_kurzbz,
'studienplan_id'=> $prestudent_status->studienplan_id,
'bestaetigtvon' => $bestaetigtvon,
'bestaetigtam' => $bestaetigtam
]);
if (isError($result))
return $result;
//Verband anlegen
$result = $this->_ci->LehrverbandModel->load([
'studiengang_kz' => $student->studiengang_kz,
'semester' => 0,
'verband' => 'A',
'gruppe' => ''
]);
if (isError($result))
return $result;
$result = getData($result);
if (!$result)
{
$result = $this->_ci->LehrverbandModel->load([
'studiengang_kz' => $student->studiengang_kz,
'semester' => 0,
'verband' => '',
'gruppe' => ''
]);
if (isError($result))
return $result;
$result = getData($result);
if(!$result)
{
$this->_ci->LehrverbandModel->insert([
'studiengang_kz' => $student->studiengang_kz,
'semester' => 0,
'verband' => '',
'gruppe' => '',
'bezeichnung' => 'Ab-Unterbrecher',
'aktiv' => true,
]);
}
$this->_ci->LehrverbandModel->insert([
'studiengang_kz' => $student->studiengang_kz,
'semester' => 0,
'verband' => 'A',
'gruppe' => '',
'bezeichnung' => 'Abbrecher',
'aktiv' => true
]);
}
//noch nicht eingetragene Zeugnisnoten auf 9 setzen
$result = $this->_ci->ZeugnisnoteModel->getZeugnisnoten($student->student_uid, $prestudent_status->studiensemester_kurzbz);
if (isError($result))
return $result;
$result = getData($result) ?: [];
foreach ($result as $lv)
{
if (!$lv->note)
{
$result = $this->_ci->ZeugnisnoteModel->insert([
'note' => 9,
'studiensemester_kurzbz' => $lv->studiensemester_kurzbz,
'student_uid' => $lv->uid,
'lehrveranstaltung_id' => $lv->lehrveranstaltung_id
]);
if (isError($result)) {
$result = $this->_ci->ZeugnisnoteModel->update([
'studiensemester_kurzbz' => $lv->studiensemester_kurzbz,
'student_uid' => $lv->uid,
'lehrveranstaltung_id' => $lv->lehrveranstaltung_id
], [
'note' => 9
]);
if (isError($result))
return $result;
}
}
}
//Update Aktionen
//StudentModel updaten
$this->_ci->StudentModel->update([
'student_uid' => $student->student_uid
], [
'verband' => 'A',
'gruppe' => '',
'semester' => 0,
'updatevon' => $insertvon,
'updateamum' => date('c')
]);
//Studentlehrverband setzen
$this->_ci->StudentlehrverbandModel->update([
'studiensemester_kurzbz' => $prestudent_status->studiensemester_kurzbz,
'student_uid' => $student->student_uid
], [
'studiengang_kz' => $student->studiengang_kz,
'semester' => 0,
'verband' => 'A',
'gruppe' => '',
'updateamum' => date('c'),
'updatevon' => $insertvon
]);
//Benutzer inaktiv setzen
$this->_ci->BenutzerModel->update([
'uid' => $student->student_uid
], [
'aktiv' => false,
'updateaktivvon' => $insertvon,
'updateaktivam' => date('c'),
'updatevon' => $insertvon,
'updateamum' => date('c')
]);
return success();
}
public function setUnterbrecher($prestudent_id, $studiensemester_kurzbz, $studierendenantrag_id, $insertvon = null)
{
$ausbildungssemester_plus = 0;
if (!$insertvon)
$insertvon = getAuthUID();
$result = $this->_ci->PrestudentstatusModel->getLastStatus($prestudent_id, $studiensemester_kurzbz);
if (isError($result))
return $result;
$result = getData($result);
if (!$result) {
//NOTE(manu): only valid if nextSemester focus max
$result = $this->_ci->PrestudentstatusModel->getLastStatus($prestudent_id);
if (isError($result))
return $result;
$result = getData($result);
//check if ausbildungssemester is last
$this->_ci->StudiengangModel->addJoin('public.tbl_prestudent p', 'studiengang_kz');
$res = $this->_ci->StudiengangModel->loadWhere(['p.prestudent_id' => $prestudent_id]);
if(isError($res))
return $res;
if(!hasData($res))
return error($this->_ci->p->t('studierendenantrag', 'error_no_stg_for_prestudent', [
'prestudent_id' => $prestudent_id
]));
$studiengang = current(getData($res));
$prestudent_status = current($result);
if($prestudent_status->ausbildungssemester + 1 < $studiengang->max_semester)
$ausbildungssemester_plus = 1;
if(!$result)
{
return error($this->_ci->p->t('studierendenantrag', 'error_no_prestudent_in_sem', [
'prestudent_id' => $prestudent_id,
'studiensemester_kurzbz' => $studiensemester_kurzbz
]));
}
}
$prestudent_status = current($result);
$result = $this->_ci->StudentModel->loadWhere(['prestudent_id' => $prestudent_id]);
if (isError($result))
return $result;
$result = getData($result);
if (!$result)
return error($this->_ci->p->t('studierendenantrag', 'error_no_student_for_prestudent', ['prestudent_id' => $prestudent_id]));
$student = current($result);
$resultAntrag = $this->_ci->StudierendenantragModel->load($studierendenantrag_id);
if (isError($resultAntrag))
return $resultAntrag;
$resultAntrag = getData($resultAntrag);
if (!$resultAntrag)
return error($this->_ci->p->t('studierendenantrag', 'error_no_antrag_found', ['id' => $studierendenantrag_id]));
$antrag = current($resultAntrag);
//Status updaten
$result = $this->_ci->PrestudentstatusModel->insert([
'prestudent_id' => $prestudent_id,
'status_kurzbz' => Prestudentstatus_model::STATUS_UNTERBRECHER,
'studiensemester_kurzbz' => $studiensemester_kurzbz,
'ausbildungssemester' => $prestudent_status->ausbildungssemester + $ausbildungssemester_plus,
'datum' => date('c'),
'insertvon' => $insertvon,
'insertamum' => date('c'),
'orgform_kurzbz'=> $prestudent_status->orgform_kurzbz,
'studienplan_id'=> $prestudent_status->studienplan_id,
'bestaetigtvon' => $insertvon,
'bestaetigtam' => date('c'),
'anmerkung'=> 'Wiedereinstieg ' . $antrag->datum_wiedereinstieg
]);
if (isError($result))
return $result;
//Verband anlegen
$result = $this->_ci->LehrverbandModel->load([
'studiengang_kz' => $student->studiengang_kz,
'semester' => 0,
'verband' => 'B',
'gruppe' => ''
]);
if (isError($result))
return $result;
$result = getData($result);
if (!$result)
{
$result = $this->_ci->LehrverbandModel->load([
'studiengang_kz' => $student->studiengang_kz,
'semester' => 0,
'verband' => '',
'gruppe' => ''
]);
if (isError($result))
return $result;
$result = getData($result);
if(!$result)
{
$this->_ci->LehrverbandModel->insert([
'studiengang_kz' => $student->studiengang_kz,
'semester' => 0,
'verband' => '',
'gruppe' => '',
'bezeichnung' => 'Ab-Unterbrecher',
'aktiv' => true,
]);
}
$this->_ci->LehrverbandModel->insert([
'studiengang_kz' => $student->studiengang_kz,
'semester' => 0,
'verband' => 'B',
'gruppe' => '',
'bezeichnung' => 'Unterbrecher',
'aktiv' => true
]);
}
//noch nicht eingetragene Zeugnisnoten auf 9 setzen
$result = $this->_ci->ZeugnisnoteModel->getZeugnisnoten($student->student_uid, $studiensemester_kurzbz);
if (isError($result))
return $result;
$result = getData($result) ?: [];
foreach ($result as $lv)
{
if (!$lv->note)
{
$result = $this->_ci->ZeugnisnoteModel->insert([
'note' => 9,
'studiensemester_kurzbz' => $lv->studiensemester_kurzbz,
'student_uid' => $lv->uid,
'lehrveranstaltung_id' => $lv->lehrveranstaltung_id
]);
if (isError($result)) {
$result = $this->_ci->ZeugnisnoteModel->update([
'studiensemester_kurzbz' => $lv->studiensemester_kurzbz,
'student_uid' => $lv->uid,
'lehrveranstaltung_id' => $lv->lehrveranstaltung_id
], [
'note' => 9
]);
if (isError($result))
return $result;
}
}
}
//Update Aktionen
//StudentModel updaten
$this->_ci->StudentModel->update([
'student_uid' => $student->student_uid
], [
'verband' => 'B',
'gruppe' => '',
'semester' => 0,
'updatevon' => $insertvon,
'updateamum' => date('c')
]);
//Studentlehrverband setzen
$result = $this->_ci->StudentlehrverbandModel->loadWhere([
'studiensemester_kurzbz' => $studiensemester_kurzbz,
'student_uid' => $student->student_uid
]);
if (hasData($result)) {
$this->_ci->StudentlehrverbandModel->update([
'studiensemester_kurzbz' => $studiensemester_kurzbz,
'student_uid' => $student->student_uid
], [
'studiengang_kz' => $student->studiengang_kz,
'semester' => 0,
'verband' => 'B',
'gruppe' => '',
'updateamum' => date('c'),
'updatevon' => $insertvon
]);
} else {
$this->_ci->StudentlehrverbandModel->insert([
'student_uid' => $student->student_uid,
'studiensemester_kurzbz' => $studiensemester_kurzbz,
'studiengang_kz' => $student->studiengang_kz,
'semester' => 0,
'verband' => 'B',
'gruppe' => '',
'insertamum' => date('c'),
'insertvon' => $insertvon
]);
}
return success();
}
}
+15 -113
View File
@@ -30,10 +30,9 @@ class SearchBarLib
const ERROR_WRONG_SEARCHSTR = 'ERR002';
const ERROR_NO_TYPES = 'ERR003';
const ERROR_WRONG_TYPES = 'ERR004';
const ERROR_NOT_AUTH = 'ERR005';
// List of allowed types of search
const ALLOWED_TYPES = ['mitarbeiter', 'mitarbeiter_ohne_zuordnung', 'organisationunit', 'raum', 'person', 'student', 'prestudent', 'document', 'cms'];
const ALLOWED_TYPES = ['mitarbeiter', 'organisationunit', 'raum', 'person', 'student', 'prestudent', 'document', 'cms'];
const PHOTO_IMG_URL = '/cis/public/bild.php?src=person&person_id=';
@@ -109,92 +108,6 @@ class SearchBarLib
return $result;
}
private function _mitarbeiter_ohne_zuordnung($searchstr, $type)
{
$dbModel = new DB_Model();
$sql = '
SELECT
\''.$type.'\' AS type,
b.uid AS uid,
p.person_id AS person_id,
p.vorname || \' \' || p.nachname AS name,
ARRAY_AGG(DISTINCT(org.bezeichnung)) AS organisationunit_name,
COALESCE(b.alias, b.uid) || \''.'@'.DOMAIN.'\' AS email,
TRIM(COALESCE(k.kontakt, \'\') || \' \' || COALESCE(m.telefonklappe, \'\')) AS phone,
\''.base_url(self::PHOTO_IMG_URL).'\' || p.person_id AS photo_url,
ARRAY_AGG(DISTINCT(stdkst.bezeichnung)) AS standardkostenstelle
FROM public.tbl_mitarbeiter m
JOIN public.tbl_benutzer b ON(b.uid = m.mitarbeiter_uid)
LEFT JOIN (
SELECT \'[\' || ot.bezeichnung || \'] \' || o.bezeichnung AS bezeichnung, bf.uid
FROM public.tbl_benutzerfunktion bf
JOIN public.tbl_organisationseinheit o USING(oe_kurzbz)
JOIN public.tbl_organisationseinheittyp ot USING(organisationseinheittyp_kurzbz)
WHERE bf.funktion_kurzbz = \'kstzuordnung\'
AND (bf.datum_von IS NULL OR bf.datum_von <= NOW())
AND (bf.datum_bis IS NULL OR bf.datum_bis >= NOW())
GROUP BY o.bezeichnung, ot.bezeichnung, bf.uid
) stdkst ON stdkst.uid = b.uid
JOIN public.tbl_person p USING(person_id)
LEFT JOIN (
SELECT \'[\' || ot.bezeichnung || \'] \' || o.bezeichnung AS bezeichnung, bf.uid
FROM public.tbl_benutzerfunktion bf
JOIN public.tbl_organisationseinheit o USING(oe_kurzbz)
JOIN public.tbl_organisationseinheittyp ot USING(organisationseinheittyp_kurzbz)
WHERE bf.funktion_kurzbz = \'oezuordnung\'
AND (bf.datum_von IS NULL OR bf.datum_von <= NOW())
AND (bf.datum_bis IS NULL OR bf.datum_bis >= NOW())
GROUP BY o.bezeichnung, ot.bezeichnung, bf.uid
) org ON org.uid = b.uid
LEFT JOIN (
SELECT kontakt, standort_id
FROM public.tbl_kontakt
WHERE kontakttyp = \'telefon\'
) k ON(k.standort_id = m.standort_id)
WHERE
(stdkst.bezeichnung IS NULL
OR org.bezeichnung IS NULL)
AND (
' .
$this->buildSearchClause(
$dbModel,
array('b.uid', 'p.vorname', 'p.nachname'),
$searchstr
) .
'
)
GROUP BY type, b.uid, p.person_id, name, email, m.telefonklappe, phone
';
$employees = $dbModel->execReadOnlyQuery($sql);
// If something has been found then return it
if (hasData($employees)) return getData($employees);
// Otherwise return an empty array
return array();
}
protected function buildSearchClause(DB_Model $dbModel, array $columns, $searchstr)
{
$document = implode(' || \' \' || ', $columns);
$query = '\'' . implode(':* & ', explode(' ', trim($searchstr))) . ':*\'';
$reversequery = '\'*:' . implode(' & *:', explode(' ', trim($searchstr))) . '\'';
$nospacequery = '\'' . implode('', explode(' ', trim($searchstr))) . ':*\'';
$searchclause = <<<EOSC
to_tsvector(lower(regexp_replace({$document}, '[[:punct:]]', ' ', 'g'))) @@ to_tsquery(lower({$query}))
OR
to_tsvector(reverse(lower(regexp_replace({$document}, '[[:punct:]]', ' ', 'g')))) @@ to_tsquery(reverse(lower({$reversequery})))
OR
to_tsvector(lower(regexp_replace({$document}, '[[:punct:]]', ' ', 'g'))) @@ to_tsquery(lower({$nospacequery}))
EOSC;
return $searchclause;
}
/**
* Search for employees
*/
@@ -216,38 +129,34 @@ EOSC;
FROM public.tbl_mitarbeiter m
JOIN public.tbl_benutzer b ON(b.uid = m.mitarbeiter_uid)
JOIN (
SELECT \'[\' || ot.bezeichnung || \'] \' || o.bezeichnung AS bezeichnung, bf.uid
SELECT o.bezeichnung, bf.uid
FROM public.tbl_benutzerfunktion bf
JOIN public.tbl_organisationseinheit o USING(oe_kurzbz)
JOIN public.tbl_organisationseinheittyp ot USING(organisationseinheittyp_kurzbz)
WHERE bf.funktion_kurzbz = \'kstzuordnung\'
AND (bf.datum_von IS NULL OR bf.datum_von <= NOW())
AND (bf.datum_bis IS NULL OR bf.datum_bis >= NOW())
GROUP BY o.bezeichnung, ot.bezeichnung, bf.uid
GROUP BY o.bezeichnung, bf.uid
) stdkst ON stdkst.uid = b.uid
JOIN public.tbl_person p USING(person_id)
JOIN (
SELECT \'[\' || ot.bezeichnung || \'] \' || o.bezeichnung AS bezeichnung, bf.uid
SELECT o.bezeichnung, bf.uid
FROM public.tbl_benutzerfunktion bf
JOIN public.tbl_organisationseinheit o USING(oe_kurzbz)
JOIN public.tbl_organisationseinheittyp ot USING(organisationseinheittyp_kurzbz)
WHERE bf.funktion_kurzbz = \'oezuordnung\'
AND (bf.datum_von IS NULL OR bf.datum_von <= NOW())
AND (bf.datum_bis IS NULL OR bf.datum_bis >= NOW())
GROUP BY o.bezeichnung, ot.bezeichnung, bf.uid
GROUP BY o.bezeichnung, bf.uid
) org ON org.uid = b.uid
LEFT JOIN (
SELECT kontakt, standort_id
FROM public.tbl_kontakt
WHERE kontakttyp = \'telefon\'
) k ON(k.standort_id = m.standort_id)
WHERE ' .
$this->buildSearchClause(
$dbModel,
array('b.uid', 'p.vorname', 'p.nachname', 'org.bezeichnung', 'stdkst.bezeichnung'),
$searchstr
) .
'
WHERE b.uid ILIKE \'%'.$dbModel->escapeLike($searchstr).'%\'
OR p.vorname ILIKE \'%'.$dbModel->escapeLike($searchstr).'%\'
OR p.nachname ILIKE \'%'.$dbModel->escapeLike($searchstr).'%\'
OR org.bezeichnung ILIKE \'%'.$dbModel->escapeLike($searchstr).'%\'
OR stdkst.bezeichnung ILIKE \'%'.$dbModel->escapeLike($searchstr).'%\'
GROUP BY type, b.uid, p.person_id, name, email, m.telefonklappe, phone
');
@@ -269,17 +178,15 @@ EOSC;
SELECT
\''.$type.'\' AS type,
o.oe_kurzbz AS oe_kurzbz,
\'[\' || ot.bezeichnung || \'] \' || o.bezeichnung AS name,
o.bezeichnung AS name,
oParent.oe_kurzbz AS parentoe_kurzbz,
(CASE WHEN oParent.bezeichnung IS NOT NULL THEN \'[\' || otParent.bezeichnung || \'] \' || oParent.bezeichnung END) AS parentoe_name,
oParent.bezeichnung AS parentoe_name,
ARRAY_AGG(DISTINCT(bfLeader.uid)) AS leader_uid,
ARRAY_AGG(DISTINCT(bfLeader.vorname || \' \' || bfLeader.nachname)) AS leader_name,
COUNT(bfCount.benutzerfunktion_id) AS number_of_people,
(CASE WHEN o.mailverteiler = TRUE THEN o.oe_kurzbz || \''.'@'.DOMAIN.'\' END) AS mailgroup
FROM public.tbl_organisationseinheit o
JOIN public.tbl_organisationseinheittyp ot USING(organisationseinheittyp_kurzbz)
LEFT JOIN public.tbl_organisationseinheit oParent ON(oParent.oe_kurzbz = o.oe_parent_kurzbz)
LEFT JOIN public.tbl_organisationseinheittyp otParent ON(oParent.organisationseinheittyp_kurzbz = otParent.organisationseinheittyp_kurzbz)
LEFT JOIN (
SELECT benutzerfunktion_id, oe_kurzbz
FROM public.tbl_benutzerfunktion
@@ -297,14 +204,9 @@ EOSC;
AND (datum_bis IS NULL OR datum_bis >= NOW())
AND b.aktiv = TRUE
) bfLeader ON(bfLeader.oe_kurzbz = o.oe_kurzbz)
WHERE ' .
$this->buildSearchClause(
$dbModel,
array('o.oe_kurzbz', 'o.bezeichnung', 'ot.bezeichnung'),
$searchstr
) .
'
GROUP BY type, o.oe_kurzbz, o.bezeichnung, ot.bezeichnung, oParent.oe_kurzbz, oParent.bezeichnung, otParent.bezeichnung
WHERE o.oe_kurzbz ILIKE \'%'.$dbModel->escapeLike($searchstr).'%\'
OR o.bezeichnung ILIKE \'%'.$dbModel->escapeLike($searchstr).'%\'
GROUP BY type, o.oe_kurzbz, o.bezeichnung, oParent.oe_kurzbz, oParent.bezeichnung
');
// If something has been found
-85
View File
@@ -1,85 +0,0 @@
<?php
/**
* Copyright (C) 2022 fhcomplete.net
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
*
*/
require_once(dirname(__FILE__).'/../../vendor/nategood/httpful/bootstrap.php');
/**
* Simple client to call the signature server
*/
class SignatureLib
{
// -------------------------------------------------------------------------------------------------
// Public static methods
/**
* Returns the list of signature inside the given file
*/
public static function list($inputFileName)
{
try
{
// Dont send Document if it is bigger than 30 MB (Limit of Signature Server)
if (filesize($inputFileName) > 30000000)
{
$returnObject = new stdClass();
$returnObject->code = 1;
$returnObject->error = 1;
$returnObject->retval = 'File to big';
return $returnObject;
}
// Get the content of the given file
$inputFileContent = file_get_contents($inputFileName);
if ($inputFileContent === false) // if failed
{
error_log('An error occurred while getting the content from: '.$inputFileName);
}
else
{
// Posts the given file content + file name and expects a response in JSON format
$resultPost = \Httpful\Request::post(SIGNATUR_URL.'/'.SIGNATUR_LIST_API)
->sendsJson()
->authenticateWith(SIGNATUR_USER, SIGNATUR_PASSWORD)
->body('{"filename": "'.basename($inputFileName).'", "content": "'.base64_encode($inputFileContent).'"}')
->expectsJson()
->send();
}
}
catch(\Httpful\Exception\ConnectionErrorException $cee) // Httpful exception
{
error_log($cee->getMessage());
}
catch (Exception $e) // any other exception
{
error_log($e->getMessage());
}
// If the response is fine
if (isset($resultPost->body) && is_object($resultPost->body)
&& isset($resultPost->body->retval) && is_array($resultPost->body->retval))
{
return $resultPost->body->retval;
}
// Otherwise return a null as error
return null;
}
}
+3 -22
View File
@@ -1,22 +1,5 @@
<?php
/**
* Copyright (C) 2023 fhcomplete.org
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
if (! defined('BASEPATH')) exit('No direct script access allowed');
/**
@@ -33,7 +16,6 @@ class TableWidgetLib
const SESSION_FIELDS = 'fields';
const SESSION_COLUMNS_ALIASES = 'columnsAliases';
const SESSION_ADDITIONAL_COLUMNS = 'additionalColumns';
const SESSION_ENCRYPTED_COLUMNS = 'encryptedColumns';
const SESSION_CHECKBOXES = 'checkboxes';
const SESSION_METADATA = 'datasetMetadata';
const SESSION_ROW_NUMBER = 'rowNumber';
@@ -67,7 +49,6 @@ class TableWidgetLib
const ADDITIONAL_COLUMNS = 'additionalColumns';
const CHECKBOXES = 'checkboxes';
const COLUMNS_ALIASES = 'columnsAliases';
const ENCRYPTED_COLUMNS = 'encryptedColumns';
// ...to format/mark records of a dataset
const FORMAT_ROW = 'formatRow';
@@ -93,7 +74,7 @@ class TableWidgetLib
/**
* Gets the CI instance and loads message helper
*/
public function __construct()
public function __construct($params = null)
{
$this->_ci =& get_instance(); // get code igniter instance
}
@@ -196,7 +177,7 @@ class TableWidgetLib
/**
* Retrieves the dataset from the DB
*/
public function getDataset($datasetQuery, $encryptedColumns)
public function getDataset($datasetQuery)
{
$dataset = null;
@@ -205,7 +186,7 @@ class TableWidgetLib
$this->_ci->load->model('system/Filters_model', 'FiltersModel');
// Execute the given SQL statement suppressing error messages
$dataset = @$this->_ci->FiltersModel->execReadOnlyQuery($datasetQuery, null, $encryptedColumns);
$dataset = @$this->_ci->FiltersModel->execReadOnlyQuery($datasetQuery);
}
return $dataset;
@@ -1,55 +0,0 @@
<?php
if (! defined('BASEPATH')) exit('No direct script access allowed');
/**
* Library containing definitions of all core plausichecks.
*/
class PlausicheckDefinitionLib
{
// set fehler for core plausichecks
// structure: fehler_kurzbz => class (library) name for resolving
private $_fehlerLibMappings = array(
'AbbrecherAktiv' => 'AbbrecherAktiv',
'AbschlussstatusFehlt' => 'AbschlussstatusFehlt',
'AktSemesterNull' => 'AktSemesterNull',
'AktiverStudentOhneStatus' => 'AktiverStudentOhneStatus',
'AusbildungssemPrestudentUngleichAusbildungssemStatus' => 'AusbildungssemPrestudentUngleichAusbildungssemStatus',
'BewerberNichtZumRtAngetreten' => 'BewerberNichtZumRtAngetreten',
'DatumAbschlusspruefungFehlt' => 'DatumAbschlusspruefungFehlt',
'DatumSponsionFehlt' => 'DatumSponsionFehlt',
'DatumStudiensemesterFalscheReihenfolge' => 'DatumStudiensemesterFalscheReihenfolge',
'FalscheAnzahlAbschlusspruefungen' => 'FalscheAnzahlAbschlusspruefungen',
'FalscheAnzahlHeimatadressen' => 'FalscheAnzahlHeimatadressen',
'FalscheAnzahlZustelladressen' => 'FalscheAnzahlZustelladressen',
'GbDatumWeitZurueck' => 'GbDatumWeitZurueck',
'InaktiverStudentAktiverStatus' => 'InaktiverStudentAktiverStatus',
'IncomingHeimatNationOesterreich' => 'IncomingHeimatNationOesterreich',
'IncomingOhneIoDatensatz' => 'IncomingOhneIoDatensatz',
'IncomingOrGsFoerderrelevant' => 'IncomingOrGsFoerderrelevant',
'InskriptionVorLetzerBismeldung' => 'InskriptionVorLetzerBismeldung',
'NationNichtOesterreichAberGemeinde' => 'NationNichtOesterreichAberGemeinde',
'OrgformStgUngleichOrgformPrestudent' => 'OrgformStgUngleichOrgformPrestudent',
'PrestudentMischformOhneOrgform' => 'PrestudentMischformOhneOrgform',
'StgPrestudentUngleichStgStudienplan' => 'StgPrestudentUngleichStgStudienplan',
'StgPrestudentUngleichStgStudent' => 'StgPrestudentUngleichStgStudent',
'StudentstatusNachAbbrecher' => 'StudentstatusNachAbbrecher'
//'StudienplanUngueltig' => 'StudienplanUngueltig'
);
/**
* Gets all fehler_kurzbz-library mappings for fehler which need to be checked.
*/
public function getFehlerLibMappings()
{
return $this->_fehlerLibMappings;
}
/**
* Gets all fehler_kurzbz for fehler which need to be checked.
*/
public function getFehlerKurzbz()
{
return array_keys($this->_fehlerLibMappings);
}
}
File diff suppressed because it is too large Load Diff
@@ -4,70 +4,77 @@ if (! defined('BASEPATH')) exit('No direct script access allowed');
class PlausicheckProducerLib
{
const CI_PATH = 'application';
const CI_LIBRARY_FOLDER = 'libraries';
const EXTENSIONS_FOLDER = 'extensions';
const CI_LIBRARY_PATH = 'application/libraries';
const PLAUSI_ISSUES_FOLDER = 'issues/plausichecks';
const EXECUTE_PLAUSI_CHECK_METHOD_NAME = 'executePlausiCheck';
private $_ci; // ci instance
private $_extensionName; // name of extension
private $_app; // name of application
private $_konfiguration = array(); // konfigratio parameters
private $_currentStudiensemester; // current Studiensemester
public function __construct($params = null)
// set fehler which can be produced by the job
// structure: fehler_kurzbz => class (library) name for resolving
private $_fehlerLibMappings = array(
'AbbrecherAktiv' => 'AbbrecherAktiv',
'AbschlussstatusFehlt' => 'AbschlussstatusFehlt',
'AktSemesterNull' => 'AktSemesterNull',
'AktiverStudentOhneStatus' => 'AktiverStudentOhneStatus',
'AusbildungssemPrestudentUngleichAusbildungssemStatus' => 'AusbildungssemPrestudentUngleichAusbildungssemStatus',
'BewerberNichtZumRtAngetreten' => 'BewerberNichtZumRtAngetreten',
'DatumAbschlusspruefungFehlt' => 'DatumAbschlusspruefungFehlt',
'DatumSponsionFehlt' => 'DatumSponsionFehlt',
'DatumStudiensemesterFalscheReihenfolge' => 'DatumStudiensemesterFalscheReihenfolge',
'FalscheAnzahlAbschlusspruefungen' => 'FalscheAnzahlAbschlusspruefungen',
'FalscheAnzahlHeimatadressen' => 'FalscheAnzahlHeimatadressen',
'FalscheAnzahlZustelladressen' => 'FalscheAnzahlZustelladressen',
'GbDatumWeitZurueck' => 'GbDatumWeitZurueck',
'InaktiverStudentAktiverStatus' => 'InaktiverStudentAktiverStatus',
'IncomingHeimatNationOesterreich' => 'IncomingHeimatNationOesterreich',
'IncomingOhneIoDatensatz' => 'IncomingOhneIoDatensatz',
'IncomingOrGsFoerderrelevant' => 'IncomingOrGsFoerderrelevant',
'InskriptionVorLetzerBismeldung' => 'InskriptionVorLetzerBismeldung',
'NationNichtOesterreichAberGemeinde' => 'NationNichtOesterreichAberGemeinde',
'OrgformStgUngleichOrgformPrestudent' => 'OrgformStgUngleichOrgformPrestudent',
'PrestudentMischformOhneOrgform' => 'PrestudentMischformOhneOrgform',
'StgPrestudentUngleichStgStudienplan' => 'StgPrestudentUngleichStgStudienplan',
'StgPrestudentUngleichStgStudent' => 'StgPrestudentUngleichStgStudent',
'StudentstatusNachAbbrecher' => 'StudentstatusNachAbbrecher'
//'StudienplanUngueltig' => 'StudienplanUngueltig'
);
public function __construct()
{
// set extension name if called from extension
if (isset($params['extensionName'])) $this->_extensionName = $params['extensionName'];
// set application
$app = isset($params['app']) ? $params['app'] : null;
$this->_ci =& get_instance(); // get ci instance
// load models
$this->_ci->load->model('system/Fehlerkonfiguration_model', 'FehlerkonfigurationModel');
$this->_ci->load->model('organisation/studiensemester_model', 'StudiensemesterModel');
// get all configuration parameters for the application
$fehlerkonfigurationRes = $this->_ci->FehlerkonfigurationModel->getKonfiguration($app);
if (hasData($fehlerkonfigurationRes))
{
$fehlerkonfiguration = getData($fehlerkonfigurationRes);
foreach ($fehlerkonfiguration as $fk)
{
$this->_konfiguration[$fk->fehler_kurzbz][$fk->konfigurationstyp_kurzbz] = $fk->konfiguration;
}
}
// get current Studiensemester
$studiensemesterRes = $this->_ci->StudiensemesterModel->getAkt();
if (hasData($studiensemesterRes)) $this->_currentStudiensemester = getData($studiensemesterRes)[0]->studiensemester_kurzbz;
}
/**
* Executes plausicheck using a given library, returns the result.
* @param $libName string name of library producing the issue
* @param $fehler_kurzbz string unique short name of fehler, for which issue is produced
* @param $params parameters passed to issue production method
* Executes check for a fehler_kurzbz, returns the result.
* @param $fehler_kurzbz string
* @param $studiensemester_kurzbz string optionally needed for issue production
* @param $studiengang_kz int optionally needed for issue production
*/
public function producePlausicheckIssue($libName, $fehler_kurzbz, $params)
public function producePlausicheckIssue($fehler_kurzbz, $studiensemester_kurzbz = null, $studiengang_kz = null)
{
// if called from extension (extension name set), path includes extension names
$libRootPath = isset($this->_extensionName) ? self::EXTENSIONS_FOLDER . '/' . $this->_extensionName . '/' : '';
$libName = $this->_fehlerLibMappings[$fehler_kurzbz];
// path for loading issue library
$issuesLibPath = $libRootPath . self::PLAUSI_ISSUES_FOLDER . '/';
// get Studiensemester
if (isEmptyString($studiensemester_kurzbz)) $studiensemester_kurzbz = $this->_currentStudiensemester;
// file path of library for check if file exists
$issuesLibFilePath = DOC_ROOT . self::CI_PATH
. '/' . $libRootPath . self::CI_LIBRARY_FOLDER . '/' . self::PLAUSI_ISSUES_FOLDER . '/' . $libName . '.php';
// get path of library for issue to be produced
$issuesLibPath = DOC_ROOT . self::CI_LIBRARY_PATH . '/' . self::PLAUSI_ISSUES_FOLDER . '/';
$issuesLibFilePath = $issuesLibPath . $libName . '.php';
// check if library file exists
if (!file_exists($issuesLibFilePath)) return error("Issue library file " . $issuesLibFilePath . " does not exist");
// load konfiguration parameters of the fehler_kurzbz
$config = isset($this->_konfiguration[$fehler_kurzbz]) ? $this->_konfiguration[$fehler_kurzbz] : null;
// load library connected to fehlercode
$this->_ci->load->library($issuesLibPath . $libName, $config);
$this->_ci->load->library(self::PLAUSI_ISSUES_FOLDER . '/'.$libName);
$lowercaseLibName = mb_strtolower($libName);
@@ -75,7 +82,21 @@ class PlausicheckProducerLib
if (!is_callable(array($this->_ci->{$lowercaseLibName}, self::EXECUTE_PLAUSI_CHECK_METHOD_NAME)))
return error("Method " . self::EXECUTE_PLAUSI_CHECK_METHOD_NAME . " is not defined in library $lowercaseLibName");
// pass the data needed for issue check
$paramsForCheck = array(
'studiensemester_kurzbz' => $studiensemester_kurzbz,
'studiengang_kz' => $studiengang_kz
);
// call the function for checking for issue production
return $this->_ci->{$lowercaseLibName}->{self::EXECUTE_PLAUSI_CHECK_METHOD_NAME}($params);
return $this->_ci->{$lowercaseLibName}->{self::EXECUTE_PLAUSI_CHECK_METHOD_NAME}($paramsForCheck);
}
/**
* Gets all fehler_kurzbz for fehler which need to be checked.
*/
public function getFehlerKurzbz()
{
return array_keys($this->_fehlerLibMappings);
}
}
@@ -13,14 +13,11 @@ class AbbrecherAktiv extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$prestudentRes = $this->getAbbrecherAktiv($studiengang_kz, null, $exkludierte_studiengang_kz);
$prestudentRes = $this->_ci->plausichecklib->getAbbrecherAktiv($studiengang_kz);
if (isError($prestudentRes)) return $prestudentRes;
@@ -43,49 +40,4 @@ class AbbrecherAktiv extends PlausiChecker
// return the results
return success($results);
}
/**
* Abbrecher cannot be active.
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param prestudent_id int if check is to be executed only for one prestudent
* @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
* @return success with prestudents or error
*/
public function getAbbrecherAktiv($studiengang_kz = null, $prestudent_id = null, $exkludierte_studiengang_kz = null)
{
$params = array();
$qry = "
SELECT
pre.person_id, pre.prestudent_id, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz
FROM
public.tbl_prestudentstatus pre_status
JOIN public.tbl_prestudent pre USING(prestudent_id)
JOIN public.tbl_student student USING(prestudent_id)
JOIN public.tbl_benutzer benutzer on(benutzer.uid=student.student_uid)
JOIN public.tbl_studiengang stg ON pre.studiengang_kz = stg.studiengang_kz
WHERE
pre_status.status_kurzbz ='Abbrecher'
AND benutzer.aktiv=true";
if (isset($studiengang_kz))
{
$qry .= " AND stg.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($prestudent_id))
{
$qry .= " AND pre.prestudent_id = ?";
$params[] = $prestudent_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -13,20 +13,12 @@ class AbschlussstatusFehlt extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiensemester_kurzbz = isset($params['studiensemester_kurzbz']) ? $params['studiensemester_kurzbz'] : null;
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$prestudentRes = $this->getAbschlussstatusFehlt(
$studiensemester_kurzbz,
$studiengang_kz,
null,
$exkludierte_studiengang_kz
);
$prestudentRes = $this->_ci->plausichecklib->getAbschlussstatusFehlt($studiensemester_kurzbz, $studiengang_kz);
if (isError($prestudentRes)) return $prestudentRes;
@@ -49,95 +41,4 @@ class AbschlussstatusFehlt extends PlausiChecker
// return the results
return success($results);
}
/**
* Prestudent should have a final status.
* @param studiensemester_kurzbz string if check is to be executed for certain Studiensemester
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param prestudent_id int if check is to be executed only for one prestudent
* @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
* @return success with prestudents or error
*/
public function getAbschlussstatusFehlt(
$studiensemester_kurzbz = null,
$studiengang_kz = null,
$prestudent_id = null,
$exkludierte_studiengang_kz = null
) {
$params = array();
$qry = "
SELECT
DISTINCT ON (pre.prestudent_id)
pre.person_id, pre.prestudent_id, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz, status.studiensemester_kurzbz
FROM
public.tbl_prestudent pre
JOIN public.tbl_person USING(person_id)
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
JOIN public.tbl_studiengang stg USING(studiengang_kz)
WHERE
NOT EXISTS( /*student does not study anymore*/
SELECT
1
FROM
public.tbl_prestudentstatus ps
JOIN public.tbl_studiensemester USING(studiensemester_kurzbz)
WHERE
prestudent_id=pre.prestudent_id
/* 4 months: There might be Diplomanden, in summer months end status is often not entered yet */
AND tbl_studiensemester.ende>now() - interval '4 months'
)
/* check only valid begininng with 2018 */
AND '2018-01-01'<(SELECT max(datum) FROM public.tbl_prestudentstatus WHERE prestudent_id=pre.prestudent_id)
AND NOT EXISTS( /* no end status */
SELECT 1
FROM public.tbl_prestudentstatus ps
WHERE
prestudent_id=pre.prestudent_id
AND status_kurzbz IN('Abbrecher','Abgewiesener','Absolvent','Incoming')
)
AND stg.melderelevant
AND pre.bismelden";
if (isset($studiensemester_kurzbz))
{
$prevStudiensemesterRes = $this->_ci->StudiensemesterModel->getPreviousFrom($studiensemester_kurzbz);
if (isError($prevStudiensemesterRes)) return $prevStudiensemesterRes;
if (hasData($prevStudiensemesterRes))
{
// if Studiensemester given, check only if has status in current or previous semester
$prevStudiensemester = getData($prevStudiensemesterRes)[0]->studiensemester_kurzbz;
$qry .= " AND EXISTS (
SELECT 1
FROM public.tbl_prestudentstatus ps
WHERE studiensemester_kurzbz IN (?, ?)
AND ps.prestudent_id = pre.prestudent_id
)";
$params[] = $prevStudiensemester;
$params[] = $studiensemester_kurzbz;
}
}
if (isset($studiengang_kz))
{
$qry .= " AND stg.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($prestudent_id))
{
$qry .= " AND pre.prestudent_id = ?";
$params[] = $prestudent_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -13,15 +13,12 @@ class AktSemesterNull extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiensemester_kurzbz = isset($params['studiensemester_kurzbz']) ? $params['studiensemester_kurzbz'] : null;
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$prestudentRes = $this->getAktSemesterNull($studiensemester_kurzbz, $studiengang_kz, null, $exkludierte_studiengang_kz);
$prestudentRes = $this->_ci->plausichecklib->getAktSemesterNull($studiensemester_kurzbz, $studiengang_kz);
if (isError($prestudentRes)) return $prestudentRes;
@@ -50,51 +47,4 @@ class AktSemesterNull extends PlausiChecker
// return the results
return success($results);
}
/**
* Current Ausbildungssemester shouldn't be 0.
* @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param prestudent_id int if check is to be executed only for one prestudent
* @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
* @return success with prestudents or error
*/
public function getAktSemesterNull($studiensemester_kurzbz, $studiengang_kz = null, $prestudent_id = null, $exkludierte_studiengang_kz = null)
{
$params = array($studiensemester_kurzbz);
$qry = "
SELECT
DISTINCT pre.person_id, pre.prestudent_id, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz, prestat.studiensemester_kurzbz
FROM
public.tbl_prestudent pre
JOIN public.tbl_prestudentstatus prestat USING(prestudent_id)
JOIN public.tbl_studiengang stg USING(studiengang_kz)
WHERE
prestat.status_kurzbz != 'Incoming'
AND prestat.studiensemester_kurzbz = ?
AND ausbildungssemester = 0
AND stg.melderelevant
AND pre.bismelden";
if (isset($studiengang_kz))
{
$qry .= " AND stg.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($prestudent_id))
{
$qry .= " AND pre.prestudent_id = ?";
$params[] = $prestudent_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -13,14 +13,11 @@ class AktiverStudentOhneStatus extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$prestudentRes = $this->getAktiverStudentOhneStatus($studiengang_kz, null, $exkludierte_studiengang_kz);
$prestudentRes = $this->_ci->plausichecklib->getAktiverStudentOhneStatus($studiengang_kz);
if (isError($prestudentRes)) return $prestudentRes;
@@ -43,57 +40,4 @@ class AktiverStudentOhneStatus extends PlausiChecker
// return the results
return success($results);
}
/**
* Students with active Benutzer should have a status in the current semester.
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param prestudent_id int if check is to be executed only for one prestudent
* @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
* @return success with prestudents or error
*/
public function getAktiverStudentOhneStatus($studiengang_kz = null, $prestudent_id = null, $exkludierte_studiengang_kz = null)
{
$params = array();
$qry = "
SELECT
DISTINCT (student_uid), prestudent.person_id, prestudent.prestudent_id, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz
FROM
public.tbl_student student
JOIN public.tbl_benutzer benutzer on (benutzer.uid = student.student_uid)
JOIN public.tbl_prestudent prestudent USING(prestudent_id)
JOIN public.tbl_studiengang stg ON prestudent.studiengang_kz = stg.studiengang_kz
WHERE
benutzer.aktiv=TRUE
AND stg.melderelevant
AND prestudent.bismelden
AND NOT EXISTS (
SELECT 1
FROM public.tbl_prestudentstatus
JOIN public.tbl_studiensemester sem USING (studiensemester_kurzbz)
WHERE prestudent_id = prestudent.prestudent_id
/* buffer of four months, as status are often entered later */
AND sem.ende::date > NOW() - interval '4 months'
)";
if (isset($studiengang_kz))
{
$qry .= " AND stg.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($prestudent_id))
{
$qry .= " AND prestudent.prestudent_id = ?";
$params[] = $prestudent_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -1,120 +0,0 @@
<?php
if (! defined('BASEPATH')) exit('No direct script access allowed');
require_once('PlausiChecker.php');
/**
* Student with active status should have been charged, i.e. have a Kontobuchung with negative or zero value.
*/
class AktiverStudentstatusOhneKontobuchung extends PlausiChecker
{
public function executePlausiCheck($params)
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiensemester_kurzbz = isset($params['studiensemester_kurzbz']) ? $params['studiensemester_kurzbz'] : null;
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$prestudentRes = $this->getAktiverStudentstatusOhneKontobuchung(
$studiensemester_kurzbz,
$studiengang_kz,
null,
$exkludierte_studiengang_kz
);
if (isError($prestudentRes)) return $prestudentRes;
if (hasData($prestudentRes))
{
$prestudents = getData($prestudentRes);
// populate results with data necessary for writing issues
foreach ($prestudents as $prestudent)
{
$results[] = array(
'person_id' => $prestudent->person_id,
'oe_kurzbz' => $prestudent->prestudent_stg_oe_kurzbz,
'fehlertext_params' => array(
'prestudent_id' => $prestudent->prestudent_id,
'studiensemester_kurzbz' => $prestudent->studiensemester_kurzbz
),
'resolution_params' => array(
'prestudent_id' => $prestudent->prestudent_id,
'studiensemester_kurzbz' => $prestudent->studiensemester_kurzbz
)
);
}
}
// return the results
return success($results);
}
/**
* Student with active status should have been charged, i.e. have a Kontobuchung with a negative or zero value.
* @param studiensemester_kurzbz string if check is to be executed for certain Studiensemester
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param prestudent_id int if check is to be executed only for one prestudent
* @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
* @return success with prestudents or error
*/
public function getAktiverStudentstatusOhneKontobuchung(
$studiensemester_kurzbz,
$studiengang_kz = null,
$prestudent_id = null,
$exkludierte_studiengang_kz = null
) {
$params = array($studiensemester_kurzbz);
$qry = "
SELECT
DISTINCT ON (pre.prestudent_id)
pre.person_id, pre.prestudent_id, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz, status.studiensemester_kurzbz
FROM
public.tbl_prestudent pre
JOIN public.tbl_person pers USING(person_id)
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
JOIN public.tbl_studiengang stg USING(studiengang_kz)
WHERE
status.studiensemester_kurzbz = ?
AND status.status_kurzbz IN ('Student', 'Incoming')
AND NOT EXISTS (
SELECT 1
FROM
public.tbl_konto
WHERE
person_id = pers.person_id
AND studiensemester_kurzbz = status.studiensemester_kurzbz
AND buchungsnr_verweis IS NULL
AND betrag <= 0
)
AND stg.melderelevant
AND pre.bismelden";
if (isset($studiengang_kz))
{
$qry .= " AND stg.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($prestudent_id))
{
$qry .= " AND pre.prestudent_id = ?";
$params[] = $prestudent_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -13,19 +13,14 @@ class AusbildungssemPrestudentUngleichAusbildungssemStatus extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiensemester_kurzbz = isset($params['studiensemester_kurzbz']) ? $params['studiensemester_kurzbz'] : null;
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$prestudentRes = $this->getAusbildungssemPrestudentUngleichAusbildungssemStatus(
$prestudentRes = $this->_ci->plausichecklib->getAusbildungssemPrestudentUngleichAusbildungssemStatus(
$studiensemester_kurzbz,
$studiengang_kz,
null,
$exkludierte_studiengang_kz
$studiengang_kz
);
if (isError($prestudentRes)) return $prestudentRes;
@@ -58,59 +53,4 @@ class AusbildungssemPrestudentUngleichAusbildungssemStatus extends PlausiChecker
// return the results
return success($results);
}
/**
* Ausbildungssemester of prestudent (lehrverband) must be the same as Ausbildungssemester of prestudentstatus.
* @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param prestudent_id int if check is to be executed only for one prestudent
* @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
* @return success with prestudents or error
*/
public function getAusbildungssemPrestudentUngleichAusbildungssemStatus(
$studiensemester_kurzbz,
$studiengang_kz = null,
$prestudent_id = null,
$exkludierte_studiengang_kz = null
) {
$params = array($studiensemester_kurzbz, $studiensemester_kurzbz, $studiensemester_kurzbz);
$qry = "
SELECT
DISTINCT(student.student_uid), student.student_uid, prestudent.person_id, prestudent.prestudent_id,
status.ausbildungssemester AS status_ausbildungssemester, lv.semester AS student_ausbildungssemester, status.studiensemester_kurzbz,
stg.oe_kurzbz AS prestudent_stg_oe_kurzbz
FROM
public.tbl_student student
JOIN public.tbl_studentlehrverband lv USING(student_uid)
JOIN public.tbl_prestudent prestudent USING(prestudent_id)
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
JOIN public.tbl_studiengang stg ON prestudent.studiengang_kz = stg.studiengang_kz
WHERE
status.studiensemester_kurzbz = ?
AND lv.studiensemester_kurzbz = ?
AND status.status_kurzbz NOT IN ('Interessent','Bewerber','Aufgenommener','Wartender','Abgewiesener','Unterbrecher')
AND get_rolle_prestudent (prestudent_id, ?)='Student'
AND status.ausbildungssemester != lv.semester";
if (isset($studiengang_kz))
{
$qry .= " AND stg.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($prestudent_id))
{
$qry .= " AND prestudent.prestudent_id = ?";
$params[] = $prestudent_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -13,20 +13,12 @@ class BewerberNichtZumRtAngetreten extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiensemester_kurzbz = isset($params['studiensemester_kurzbz']) ? $params['studiensemester_kurzbz'] : null;
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$prestudentRes = $this->getBewerberNichtZumRtAngetreten(
$studiensemester_kurzbz,
$studiengang_kz,
null,
$exkludierte_studiengang_kz
);
$prestudentRes = $this->_ci->plausichecklib->getBewerberNichtZumRtAngetreten($studiensemester_kurzbz, $studiengang_kz);
if (isError($prestudentRes)) return $prestudentRes;
@@ -52,72 +44,4 @@ class BewerberNichtZumRtAngetreten extends PlausiChecker
// return the results
return success($results);
}
/**
* Bewerber should have participated in Reihungstest.
* @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param prestudent_id int if check is to be executed only for one prestudent
* @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
* @return success with prestudents or error
*/
public function getBewerberNichtZumRtAngetreten(
$studiensemester_kurzbz,
$studiengang_kz = null,
$prestudent_id = null,
$exkludierte_studiengang_kz = null
) {
$this->_ci->load->model('organisation/Studiensemester_model', 'StudiensemesterModel');
$previousStudiensemesterRes = $this->_ci->StudiensemesterModel->getPreviousFrom($studiensemester_kurzbz);
if (isError($previousStudiensemesterRes)) return $previousStudiensemesterRes;
$params = array($studiensemester_kurzbz);
$qry = "
SELECT
prestudent.person_id, prestudent.prestudent_id, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz, status.studiensemester_kurzbz
FROM
public.tbl_prestudent prestudent
JOIN public.tbl_prestudentstatus status ON(prestudent.prestudent_id=status.prestudent_id)
JOIN public.tbl_person USING(person_id)
LEFT JOIN bis.tbl_orgform USING(orgform_kurzbz)
JOIN public.tbl_studiengang stg USING(studiengang_kz)
WHERE
status_kurzbz='Bewerber'
AND reihungstestangetreten=false
AND stg.melderelevant
AND prestudent.bismelden";
if (hasData($previousStudiensemesterRes))
{
$previousStudiensemester = getData($previousStudiensemesterRes)[0]->studiensemester_kurzbz;
$qry .= " AND (studiensemester_kurzbz=? OR studiensemester_kurzbz=?)";
$params[] = $previousStudiensemester;
}
else
{
$qry .= " AND studiensemester_kurzbz=?";
}
if (isset($studiengang_kz))
{
$qry .= " AND stg.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($prestudent_id))
{
$qry .= " AND prestudent.prestudent_id = ?";
$params[] = $prestudent_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -13,20 +13,12 @@ class DatumAbschlusspruefungFehlt extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiensemester_kurzbz = isset($params['studiensemester_kurzbz']) ? $params['studiensemester_kurzbz'] : null;
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$prestudentRes = $this->getDatumAbschlusspruefungFehlt(
$studiensemester_kurzbz,
$studiengang_kz,
null,
$exkludierte_studiengang_kz
);
$prestudentRes = $this->_ci->plausichecklib->getDatumAbschlusspruefungFehlt($studiensemester_kurzbz, $studiengang_kz);
if (isError($prestudentRes)) return $prestudentRes;
@@ -52,72 +44,4 @@ class DatumAbschlusspruefungFehlt extends PlausiChecker
// return the results
return success($results);
}
/**
* Date of final exam shouldn't be missing for Absolvent.
* @param studiensemester_kurzbz string if check is to be executed for certain Studiensemester
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param abschlusspruefung_id int if check is to be executed for a certain Abschlussprüfung
* @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
* @return success with prestudents or error
*/
public function getDatumAbschlusspruefungFehlt(
$studiensemester_kurzbz = null,
$studiengang_kz = null,
$abschlusspruefung_id = null,
$exkludierte_studiengang_kz = null
) {
$params = array();
$qry = "
SELECT
pre.person_id, pre.prestudent_id,
pruefung.sponsion, pruefung.datum, pruefung.abschlusspruefung_id,
stg.oe_kurzbz AS prestudent_stg_oe_kurzbz
FROM
public.tbl_prestudent pre
JOIN public.tbl_student stud USING(prestudent_id)
JOIN public.tbl_prestudentstatus prestatus USING(prestudent_id)
JOIN public.tbl_studiengang stg ON pre.studiengang_kz = stg.studiengang_kz
JOIN lehre.tbl_abschlusspruefung pruefung ON stud.student_uid = pruefung.student_uid
WHERE
status_kurzbz = 'Absolvent'
AND NOT EXISTS ( /* exclude gs */
SELECT 1
FROM bis.tbl_mobilitaet
WHERE prestudent_id = pre.prestudent_id
AND studiensemester_kurzbz = prestatus.studiensemester_kurzbz
)
AND abschlussbeurteilung_kurzbz!='nicht'
AND abschlussbeurteilung_kurzbz IS NOT NULL
AND pruefung.datum IS NULL
AND pre.bismelden
AND stg.melderelevant";
if (isset($studiensemester_kurzbz))
{
$qry .= " AND prestatus.studiensemester_kurzbz = ?";
$params[] = $studiensemester_kurzbz;
}
if (isset($studiengang_kz))
{
$qry .= " AND stg.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($abschlusspruefung_id))
{
$qry .= " AND pruefung.abschlusspruefung_id = ?";
$params[] = $abschlusspruefung_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -13,20 +13,12 @@ class DatumSponsionFehlt extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiensemester_kurzbz = isset($params['studiensemester_kurzbz']) ? $params['studiensemester_kurzbz'] : null;
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$prestudentRes = $this->getDatumSponsionFehlt(
$studiensemester_kurzbz,
$studiengang_kz,
null,
$exkludierte_studiengang_kz
);
$prestudentRes = $this->_ci->plausichecklib->getDatumSponsionFehlt($studiensemester_kurzbz, $studiengang_kz);
if (isError($prestudentRes)) return $prestudentRes;
@@ -52,72 +44,4 @@ class DatumSponsionFehlt extends PlausiChecker
// return the results
return success($results);
}
/**
* Date of sponsion shouldn't be missing for Absolvent.
* @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param abschlusspruefung_id int if check is to be executed only for a certain Abschlussprüfung
* @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
* @return success with prestudents or error
*/
public function getDatumSponsionFehlt(
$studiensemester_kurzbz = null,
$studiengang_kz = null,
$abschlusspruefung_id = null,
$exkludierte_studiengang_kz = null
) {
$params = array();
$qry = "
SELECT
pre.person_id, pre.prestudent_id,
pruefung.sponsion, pruefung.datum, pruefung.abschlusspruefung_id,
stg.oe_kurzbz AS prestudent_stg_oe_kurzbz
FROM
public.tbl_prestudent pre
JOIN public.tbl_student stud USING(prestudent_id)
JOIN public.tbl_prestudentstatus prestatus USING(prestudent_id)
JOIN public.tbl_studiengang stg ON pre.studiengang_kz = stg.studiengang_kz
JOIN lehre.tbl_abschlusspruefung pruefung ON stud.student_uid = pruefung.student_uid
WHERE
status_kurzbz = 'Absolvent'
AND NOT EXISTS ( /* exclude gs */
SELECT 1
FROM bis.tbl_mobilitaet
WHERE prestudent_id = pre.prestudent_id
AND studiensemester_kurzbz = prestatus.studiensemester_kurzbz
)
AND abschlussbeurteilung_kurzbz!='nicht'
AND abschlussbeurteilung_kurzbz IS NOT NULL
AND pruefung.sponsion IS NULL
AND pre.bismelden
AND stg.melderelevant";
if (isset($studiensemester_kurzbz))
{
$qry .= " AND prestatus.studiensemester_kurzbz = ?";
$params[] = $studiensemester_kurzbz;
}
if (isset($studiengang_kz))
{
$qry .= " AND stg.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($abschlusspruefung_id))
{
$qry .= " AND pruefung.abschlusspruefung_id = ?";
$params[] = $abschlusspruefung_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -13,14 +13,11 @@ class DatumStudiensemesterFalscheReihenfolge extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$prestudentRes = $this->getDatumStudiensemesterFalscheReihenfolge($studiengang_kz, null, $exkludierte_studiengang_kz);
$prestudentRes = $this->_ci->plausichecklib->getDatumStudiensemesterFalscheReihenfolge($studiengang_kz);
if (isError($prestudentRes)) return $prestudentRes;
@@ -45,64 +42,4 @@ class DatumStudiensemesterFalscheReihenfolge extends PlausiChecker
// return the results
return success($results);
}
/**
* Status Dates and status studysemester dates should be in correct order.
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param prestudent_id int if check is to be executed only for one prestudent
* @param exkludierte_studiengang_kz array if check is to be executed only for certain Studiengaenge
* @return success with prestudents or error
*/
public function getDatumStudiensemesterFalscheReihenfolge($studiengang_kz = null, $prestudent_id = null, $exkludierte_studiengang_kz = null)
{
$params = array();
// all active students with Status student in current semester
$qry = "
SELECT DISTINCT ON (prestudent_id) *
FROM (
SELECT
prestudent.person_id, prestudent.prestudent_id,
stg.studiengang_kz, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz,
ROW_NUMBER () OVER (
PARTITION BY prestudent.prestudent_id
ORDER BY sem.start DESC, status.datum DESC, status.insertamum DESC, status.ext_id DESC
) AS reihenfolge_semester,
ROW_NUMBER () OVER (
PARTITION BY prestudent.prestudent_id
ORDER BY status.datum DESC, status.insertamum DESC, status.ext_id DESC
) AS reihenfolge_datum
FROM
public.tbl_student student
JOIN public.tbl_benutzer benutzer on(student.student_uid = benutzer.uid)
JOIN public.tbl_prestudent prestudent USING(prestudent_id)
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
JOIN public.tbl_studiensemester sem USING(studiensemester_kurzbz)
JOIN public.tbl_studiengang stg ON prestudent.studiengang_kz = stg.studiengang_kz
WHERE
benutzer.aktiv=true
AND status.status_kurzbz='Student'
) reihenfolge
WHERE reihenfolge_semester <> reihenfolge_datum";
if (isset($studiengang_kz))
{
$qry .= " AND studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($prestudent_id))
{
$qry .= " AND prestudent_id = ?";
$params[] = $prestudent_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -13,20 +13,12 @@ class FalscheAnzahlAbschlusspruefungen extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiensemester_kurzbz = isset($params['studiensemester_kurzbz']) ? $params['studiensemester_kurzbz'] : null;
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$prestudentRes = $this->getFalscheAnzahlAbschlusspruefungen(
$studiensemester_kurzbz,
$studiengang_kz,
null,
$exkludierte_studiengang_kz
);
$prestudentRes = $this->_ci->plausichecklib->getFalscheAnzahlAbschlusspruefungen($studiensemester_kurzbz, $studiengang_kz);
if (isError($prestudentRes)) return $prestudentRes;
@@ -49,77 +41,4 @@ class FalscheAnzahlAbschlusspruefungen extends PlausiChecker
// return the results
return success($results);
}
/**
* Students with finished studies should have exactly one final exam.
* @param studiensemester_kurzbz string if check is to be executed for certain Studiensemester
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param prestudent_id int if check is to be executed only for one prestudent
* @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
* @return success with prestudents or error
*/
public function getFalscheAnzahlAbschlusspruefungen(
$studiensemester_kurzbz = null,
$studiengang_kz = null,
$prestudent_id = null,
$exkludierte_studiengang_kz = null
) {
$params = array();
$qry = "
SELECT * FROM (
SELECT
DISTINCT ON(pre.prestudent_id) pre.person_id, pre.prestudent_id, student_uid, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz,
(
SELECT COUNT(*)
FROM lehre.tbl_abschlusspruefung
WHERE student_uid = stud.student_uid
AND abschlussbeurteilung_kurzbz != 'nicht'
AND abschlussbeurteilung_kurzbz IS NOT NULL
) AS anzahl_abschlusspruefungen
FROM
public.tbl_prestudent pre
JOIN public.tbl_student stud USING(prestudent_id)
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
JOIN public.tbl_studiengang stg ON pre.studiengang_kz = stg.studiengang_kz
WHERE
status_kurzbz = 'Absolvent'
AND pre.bismelden
AND stg.melderelevant
AND NOT EXISTS ( /* exclude gs */
SELECT 1
FROM bis.tbl_mobilitaet
WHERE prestudent_id = pre.prestudent_id
AND studiensemester_kurzbz = status.studiensemester_kurzbz
)";
if (isset($studiensemester_kurzbz))
{
$qry .= " AND status.studiensemester_kurzbz = ?";
$params[] = $studiensemester_kurzbz;
}
if (isset($studiengang_kz))
{
$qry .= " AND stg.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($prestudent_id))
{
$qry .= " AND pre.prestudent_id = ?";
$params[] = $prestudent_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
$qry .= ") studenten
WHERE anzahl_abschlusspruefungen != 1";
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -13,20 +13,12 @@ class FalscheAnzahlHeimatadressen extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiensemester_kurzbz = isset($params['studiensemester_kurzbz']) ? $params['studiensemester_kurzbz'] : null;
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$personRes = $this->getFalscheAnzahlHeimatadressen(
$studiensemester_kurzbz,
$studiengang_kz,
null,
$exkludierte_studiengang_kz
);
$personRes = $this->_ci->plausichecklib->getFalscheAnzahlHeimatadressen($studiensemester_kurzbz, $studiengang_kz);
if (isError($personRes)) return $personRes;
@@ -47,67 +39,4 @@ class FalscheAnzahlHeimatadressen extends PlausiChecker
// return the results
return success($results);
}
/**
* Students should have exactly one home address.
* @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param person_id int if check is to be executed only for one person
* @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
* @return success with prestudents or error
*/
public function getFalscheAnzahlHeimatadressen(
$studiensemester_kurzbz = null,
$studiengang_kz = null,
$person_id = null,
$exkludierte_studiengang_kz = null
) {
$params = array();
$qry = "
SELECT
DISTINCT person_id
FROM
(
SELECT person_id, COUNT(adresse_id) AS anzahl_adressen
FROM public.tbl_adresse addr
WHERE heimatadresse IS TRUE
GROUP BY person_id
) adressen
JOIN public.tbl_person USING(person_id)
JOIN public.tbl_prestudent pre USING(person_id)
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
JOIN public.tbl_student USING(prestudent_id)
JOIN public.tbl_studiengang stg ON pre.studiengang_kz = stg.studiengang_kz
WHERE
anzahl_adressen != 1
AND stg.melderelevant
AND pre.bismelden";
if (isset($studiensemester_kurzbz))
{
$qry .= " AND status.studiensemester_kurzbz = ?";
$params[] = $studiensemester_kurzbz;
}
if (isset($studiengang_kz))
{
$qry .= " AND stg.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($person_id))
{
$qry .= " AND person_id = ?";
$params[] = $person_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -13,20 +13,12 @@ class FalscheAnzahlZustelladressen extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiensemester_kurzbz = isset($params['studiensemester_kurzbz']) ? $params['studiensemester_kurzbz'] : null;
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$personRes = $this->getFalscheAnzahlZustelladressen(
$studiensemester_kurzbz,
$studiengang_kz,
null,
$exkludierte_studiengang_kz
);
$personRes = $this->_ci->plausichecklib->getFalscheAnzahlZustelladressen($studiensemester_kurzbz, $studiengang_kz);
if (isError($personRes)) return $personRes;
@@ -47,67 +39,4 @@ class FalscheAnzahlZustelladressen extends PlausiChecker
// return the results
return success($results);
}
/**
* Students should have exactly one delivery address.
* @param studiensemester_kurzbz string if check is to be executed for certain Studiensemester
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param person_id int if check is to be executed only for one person
* @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
* @return success with prestudents or error
*/
public function getFalscheAnzahlZustelladressen(
$studiensemester_kurzbz = null,
$studiengang_kz = null,
$person_id = null,
$exkludierte_studiengang_kz = null
) {
$params = array();
$qry = "
SELECT
DISTINCT person_id
FROM
(
SELECT person_id, COUNT(adresse_id) AS anzahl_adressen
FROM public.tbl_adresse addr
WHERE zustelladresse IS TRUE
GROUP BY person_id
) adressen
JOIN public.tbl_person USING(person_id)
JOIN public.tbl_prestudent pre USING(person_id)
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
JOIN public.tbl_student USING(prestudent_id)
JOIN public.tbl_studiengang stg ON pre.studiengang_kz = stg.studiengang_kz
WHERE
anzahl_adressen != 1
AND stg.melderelevant
AND pre.bismelden";
if (isset($studiensemester_kurzbz))
{
$qry .= " AND status.studiensemester_kurzbz = ?";
$params[] = $studiensemester_kurzbz;
}
if (isset($studiengang_kz))
{
$qry .= " AND stg.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($person_id))
{
$qry .= " AND person_id = ?";
$params[] = $person_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -13,15 +13,12 @@ class GbDatumWeitZurueck extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiensemester_kurzbz = isset($params['studiensemester_kurzbz']) ? $params['studiensemester_kurzbz'] : null;
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$personRes = $this->getGbDatumWeitZurueck($studiensemester_kurzbz, $studiengang_kz, null, $exkludierte_studiengang_kz);
$personRes = $this->_ci->plausichecklib->getGbDatumWeitZurueck($studiensemester_kurzbz, $studiengang_kz);
if (isError($personRes)) return $personRes;
@@ -42,63 +39,4 @@ class GbDatumWeitZurueck extends PlausiChecker
// return the results
return success($results);
}
/**
* Birthdate is too long ago.
* @param studiensemester_kurzbz string if check is to be executed for certain Studiensemester
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param person_id int if check is to be executed only for one person
* @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
* @return success with prestudents or error
*/
public function getGbDatumWeitZurueck(
$studiensemester_kurzbz = null,
$studiengang_kz = null,
$person_id = null,
$exkludierte_studiengang_kz = null
) {
$params = array();
$qry = "
SELECT
pers.person_id
FROM
public.tbl_person pers
WHERE
pers.gebdatum < '1920-01-01'
AND EXISTS (
SELECT 1
FROM public.tbl_prestudent
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
JOIN public.tbl_studiengang stg USING(studiengang_kz)
WHERE person_id = pers.person_id";
if (isset($studiensemester_kurzbz))
{
$qry .= " AND status.studiensemester_kurzbz = ?";
$params[] = $studiensemester_kurzbz;
}
if (isset($studiengang_kz))
{
$qry .= " AND stg.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
$qry .= ")";
if (isset($person_id))
{
$qry .= " AND pers.person_id = ?";
$params[] = $person_id;
}
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -13,20 +13,12 @@ class InaktiverStudentAktiverStatus extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiensemester_kurzbz = isset($params['studiensemester_kurzbz']) ? $params['studiensemester_kurzbz'] : null;
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$prestudentRes = $this->getInaktiverStudentAktiverStatus(
$studiensemester_kurzbz,
$studiengang_kz,
null,
$exkludierte_studiengang_kz
);
$prestudentRes = $this->_ci->plausichecklib->getInaktiverStudentAktiverStatus($studiensemester_kurzbz, $studiengang_kz);
if (isError($prestudentRes)) return $prestudentRes;
@@ -52,62 +44,4 @@ class InaktiverStudentAktiverStatus extends PlausiChecker
// return the results
return success($results);
}
/**
* Students with active status should have an active Benutzer.
* @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param prestudent_id int if check is to be executed only for one prestudent
* @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
* @return success with prestudents or error
*/
public function getInaktiverStudentAktiverStatus(
$studiensemester_kurzbz,
$studiengang_kz = null,
$prestudent_id = null,
$exkludierte_studiengang_kz = null
) {
$aktStudiensemesterRes = $this->_ci->StudiensemesterModel->getAkt();
if (isError($aktStudiensemesterRes)) return $aktStudiensemesterRes;
$studiensemester_kurzbz = hasData($aktStudiensemesterRes) ? getData($aktStudiensemesterRes)[0]->studiensemester_kurzbz : '';
$params = array($studiensemester_kurzbz);
$qry = "
SELECT
DISTINCT(student.student_uid), prestudent.person_id, prestudent.prestudent_id, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz
FROM
public.tbl_benutzer benutzer
JOIN public.tbl_student student on(benutzer.uid = student.student_uid)
JOIN public.tbl_prestudent prestudent USING(prestudent_id)
JOIN public.tbl_studiengang stg ON prestudent.studiengang_kz = stg.studiengang_kz
WHERE
benutzer.aktiv=false
AND EXISTS (SELECT 1 FROM public.tbl_prestudentstatus WHERE prestudent_id = prestudent.prestudent_id AND studiensemester_kurzbz = ?)
AND get_rolle_prestudent(prestudent_id, NULL) IN ('Student', 'Diplomand', 'Unterbrecher', 'Praktikant')
AND stg.melderelevant
AND prestudent.bismelden";
if (isset($studiengang_kz))
{
$qry .= " AND stg.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($prestudent_id))
{
$qry .= " AND prestudent.prestudent_id = ?";
$params[] = $prestudent_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -13,20 +13,12 @@ class IncomingHeimatNationOesterreich extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiensemester_kurzbz = isset($params['studiensemester_kurzbz']) ? $params['studiensemester_kurzbz'] : null;
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$personRes = $this->getIncomingHeimatNationOesterreich(
$studiensemester_kurzbz,
$studiengang_kz,
null,
$exkludierte_studiengang_kz
);
$personRes = $this->_ci->plausichecklib->getIncomingHeimatNationOesterreich($studiensemester_kurzbz, $studiengang_kz);
if (isError($personRes)) return $personRes;
@@ -47,58 +39,4 @@ class IncomingHeimatNationOesterreich extends PlausiChecker
// return the results
return success($results);
}
/**
* Incoming shouldn't have austrian home address.
* @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param person_id int if check is to be executed only for one person
* @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
* @return success with prestudents or error
*/
public function getIncomingHeimatNationOesterreich(
$studiensemester_kurzbz,
$studiengang_kz = null,
$person_id = null,
$exkludierte_studiengang_kz = null
) {
$params = array($studiensemester_kurzbz);
$qry = "
SELECT
DISTINCT pers.person_id, status.studiensemester_kurzbz
FROM
public.tbl_prestudent pre
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
JOIN public.tbl_person pers USING(person_id)
JOIN public.tbl_adresse addr USING(person_id)
JOIN public.tbl_studiengang stg USING(studiengang_kz)
WHERE
status.status_kurzbz = 'Incoming'
AND addr.nation = 'A'
AND addr.heimatadresse
AND status.studiensemester_kurzbz = ?
AND stg.melderelevant
AND pre.bismelden";
if (isset($studiengang_kz))
{
$qry .= " AND stg.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($person_id))
{
$qry .= " AND pers.person_id = ?";
$params[] = $person_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -13,14 +13,11 @@ class IncomingOhneIoDatensatz extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$prestudentRes = $this->getIncomingOhneIoDatensatz($studiengang_kz, null, $exkludierte_studiengang_kz);
$prestudentRes = $this->_ci->plausichecklib->getIncomingOhneIoDatensatz($studiengang_kz);
if (isError($prestudentRes)) return $prestudentRes;
@@ -43,54 +40,4 @@ class IncomingOhneIoDatensatz extends PlausiChecker
// return the results
return success($results);
}
/**
* Incoming should have IN/OUT data.
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param prestudent_id int if check is to be executed only for one prestudent
* @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
* @return success with prestudents or error
*/
public function getIncomingOhneIoDatensatz($studiengang_kz = null, $prestudent_id = null, $exkludierte_studiengang_kz = null)
{
$params = array();
$qry = "
SELECT
DISTINCT ON(student_uid, nachname, vorname)
tbl_person.person_id,
tbl_prestudent.prestudent_id,
stg.oe_kurzbz AS prestudent_stg_oe_kurzbz
FROM
public.tbl_student
JOIN public.tbl_benutzer ON(student_uid=uid)
JOIN public.tbl_person USING(person_id)
JOIN public.tbl_prestudent USING(prestudent_id)
JOIN public.tbl_prestudentstatus ON(tbl_prestudent.prestudent_id=tbl_prestudentstatus.prestudent_id)
JOIN public.tbl_studiengang stg ON(stg.studiengang_kz=tbl_student.studiengang_kz)
WHERE
bismelden=TRUE
AND status_kurzbz='Incoming' AND NOT EXISTS (SELECT 1 FROM bis.tbl_bisio WHERE student_uid=tbl_student.student_uid)
AND stg.melderelevant";
if (isset($studiengang_kz))
{
$qry .= " AND stg.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($prestudent_id))
{
$qry .= " AND tbl_prestudent.prestudent_id = ?";
$params[] = $prestudent_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -13,20 +13,12 @@ class IncomingOrGsFoerderrelevant extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiensemester_kurzbz = isset($params['studiensemester_kurzbz']) ? $params['studiensemester_kurzbz'] : null;
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$prestudentRes = $this->getIncomingOrGsFoerderrelevant(
$studiensemester_kurzbz,
$studiengang_kz,
null,
$exkludierte_studiengang_kz
);
$prestudentRes = $this->_ci->plausichecklib->getIncomingOrGsFoerderrelevant($studiensemester_kurzbz, $studiengang_kz);
if (isError($prestudentRes)) return $prestudentRes;
@@ -49,77 +41,4 @@ class IncomingOrGsFoerderrelevant extends PlausiChecker
// return the results
return success($results);
}
/**
* Incoming or gemeinsame Studien students should not receive funding (not be förderrelevant).
* @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param prestudent_id int if check is to be executed only for one prestudent
* @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
* @return object success or error
*/
public function getIncomingOrGsFoerderrelevant(
$studiensemester_kurzbz = null,
$studiengang_kz = null,
$prestudent_id = null,
$exkludierte_studiengang_kz = null
) {
$params = array();
$qry = "
SELECT
DISTINCT ON(prestudent_id)
pers.person_id,
ps.prestudent_id,
stg.oe_kurzbz AS prestudent_stg_oe_kurzbz
FROM
public.tbl_student stud
JOIN public.tbl_benutzer ON(student_uid=uid)
JOIN public.tbl_person pers USING(person_id)
JOIN public.tbl_prestudent ps USING(prestudent_id)
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
JOIN public.tbl_studiengang stg ON(stg.studiengang_kz=stud.studiengang_kz)
WHERE
(
status.status_kurzbz = 'Incoming'
OR EXISTS (
SELECT 1
FROM
bis.tbl_mobilitaet
JOIN public.tbl_prestudent USING(prestudent_id)
WHERE
prestudent_id = ps.prestudent_id
AND gsstudientyp_kurzbz = 'Extern'
)
)
AND (ps.foerderrelevant <> FALSE OR ps.foerderrelevant IS NULL)
AND bismelden=TRUE
AND stg.melderelevant";
if (isset($studiensemester_kurzbz))
{
$qry .= " AND status.studiensemester_kurzbz = ?";
$params[] = $studiensemester_kurzbz;
}
if (isset($studiengang_kz))
{
$qry .= " AND stg.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($prestudent_id))
{
$qry .= " AND ps.prestudent_id = ?";
$params[] = $prestudent_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -13,20 +13,12 @@ class InskriptionVorLetzerBismeldung extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiensemester_kurzbz = isset($params['studiensemester_kurzbz']) ? $params['studiensemester_kurzbz'] : null;
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$prestudentRes = $this->getInskriptionVorLetzerBismeldung(
$studiensemester_kurzbz,
$studiengang_kz,
null,
$exkludierte_studiengang_kz
);
$prestudentRes = $this->_ci->plausichecklib->getInskriptionVorLetzerBismeldung($studiensemester_kurzbz, $studiengang_kz);
if (isError($prestudentRes)) return $prestudentRes;
@@ -56,93 +48,4 @@ class InskriptionVorLetzerBismeldung extends PlausiChecker
// return the results
return success($results);
}
/**
* Students of a semester shouldn't start studies before the date of Bismeldung.
* e.g. If student studies in WS2022 datum of status shouldn't be before 15.4.2020
* e.g. If student studies in SS2022 datum of status shouldn't be before 15.11.2022
* @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param prestudent_id int if check is to be executed only for one prestudent
* @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
* @return success with prestudents or error
*/
public function getInskriptionVorLetzerBismeldung(
$studiensemester_kurzbz,
$studiengang_kz = null,
$prestudent_id = null,
$exkludierte_studiengang_kz = null
) {
// get Bismeldedatum
$datumBis = $this->_getBisdateFromSemester($studiensemester_kurzbz);
$params = array($datumBis, $studiensemester_kurzbz, $datumBis);
// get active students
$qry = "
SELECT
DISTINCT ON (student.student_uid) ? AS datum_bismeldung,
prestudent.person_id, prestudent.prestudent_id, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz, status.studiensemester_kurzbz
FROM
public.tbl_benutzer benutzer
JOIN public.tbl_student student on(benutzer.uid = student.student_uid)
JOIN public.tbl_prestudent prestudent USING(prestudent_id)
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
JOIN public.tbl_studiengang stg ON prestudent.studiengang_kz = stg.studiengang_kz
WHERE
benutzer.aktiv=true
AND status.studiensemester_kurzbz = ?
/* inscription date before date of first student status */
AND (
SELECT datum
FROM public.tbl_prestudentstatus
WHERE prestudent_id = prestudent.prestudent_id
AND studiensemester_kurzbz = status.studiensemester_kurzbz
AND status_kurzbz = 'Student'
ORDER BY datum, insertamum, ext_id
LIMIT 1
) < ?
AND stg.melderelevant
AND prestudent.bismelden";
if (isset($studiengang_kz))
{
$qry .= " AND stg.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($prestudent_id))
{
$qry .= " AND prestudent.prestudent_id = ?";
$params[] = $prestudent_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
return $this->_db->execReadOnlyQuery($qry, $params);
}
/**
* Gets Bismeldedate from Studiensemester.
* @param studiensemester_kurzbz string
*/
private function _getBisdateFromSemester($studiensemester_kurzbz)
{
$semesterYear = substr($studiensemester_kurzbz, 2, 6);
$semesterType = substr($studiensemester_kurzbz, 0, 2);
if ($semesterType == 'SS')
{
return date_format(date_create(($semesterYear - 1)."-11-15"), 'Y-m-d');
}
if ($semesterType == 'WS')
{
return date_format(date_create($semesterYear."-04-15"), 'Y-m-d');
}
}
}
@@ -13,18 +13,11 @@ class NationNichtOesterreichAberGemeinde extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$personRes = $this->getNationNichtOesterreichAberGemeinde(
$studiengang_kz,
null,
$exkludierte_studiengang_kz
);
$personRes = $this->_ci->plausichecklib->getNationNichtOesterreichAberGemeinde($studiengang_kz);
if (isError($personRes)) return $personRes;
@@ -46,49 +39,4 @@ class NationNichtOesterreichAberGemeinde extends PlausiChecker
// return the results
return success($results);
}
/**
* Nation is not Austria, but address has austrian Gemeinde.
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param person_id int if check is to be executed only for one person
* @return success with prestudents or error
*/
public function getNationNichtOesterreichAberGemeinde($studiengang_kz = null, $person_id = null, $exkludierte_studiengang_kz = null)
{
$params = array();
$qry = "SELECT DISTINCT tbl_person.person_id, adr.gemeinde, adr.adresse_id
FROM
public.tbl_adresse adr
JOIN public.tbl_prestudent USING(person_id)
JOIN public.tbl_person USING(person_id)
JOIN public.tbl_student USING(prestudent_id)
JOIN public.tbl_benutzer ON(uid=student_uid)
JOIN public.tbl_studiengang stg ON tbl_prestudent.studiengang_kz = stg.studiengang_kz
WHERE
adr.nation!='A'
AND tbl_benutzer.aktiv
AND gemeinde NOT IN ('Münster')
AND EXISTS(SELECT 1 FROM bis.tbl_gemeinde WHERE name = adr.gemeinde)";
if (isset($studiengang_kz))
{
$qry .= " AND stg.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($person_id))
{
$qry .= " AND tbl_person.person_id = ?";
$params[] = $person_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -13,20 +13,12 @@ class OrgformStgUngleichOrgformPrestudent extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiensemester_kurzbz = isset($params['studiensemester_kurzbz']) ? $params['studiensemester_kurzbz'] : null;
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$prestudentRes = $this->getOrgformStgUngleichOrgformPrestudent(
$studiensemester_kurzbz,
$studiengang_kz,
null,
$exkludierte_studiengang_kz
);
$prestudentRes = $this->_ci->plausichecklib->getOrgformStgUngleichOrgformPrestudent($studiensemester_kurzbz, $studiengang_kz);
if (isError($prestudentRes)) return $prestudentRes;
@@ -57,74 +49,4 @@ class OrgformStgUngleichOrgformPrestudent extends PlausiChecker
// return the results
return success($results);
}
/**
* Orgform of a Studiengang in Studienplan should be the same as orgform of student.
* @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param prestudent_id int if check is to be executed only for one prestudent
* @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
* @return success with prestudents or error
*/
public function getOrgformStgUngleichOrgformPrestudent(
$studiensemester_kurzbz,
$studiengang_kz = null,
$prestudent_id = null,
$exkludierte_studiengang_kz = null
) {
$params = array($studiensemester_kurzbz);
$qry = "
SELECT
prestudent.person_id, prestudent.prestudent_id, status.studiensemester_kurzbz,
studiengang.orgform_kurzbz AS stg_orgform, status.orgform_kurzbz AS student_orgform,
prestudent.studiengang_kz AS student_studiengang, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz
FROM
public.tbl_studiengang studiengang
JOIN public.tbl_student student USING(studiengang_kz)
JOIN public.tbl_prestudent prestudent USING(prestudent_id)
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
JOIN public.tbl_benutzer benutzer on(benutzer.uid = student.student_uid)
JOIN public.tbl_studiengang stg ON prestudent.studiengang_kz = stg.studiengang_kz
LEFT JOIN lehre.tbl_studienplan stpl USING (studienplan_id)
WHERE
benutzer.aktiv = true
AND status.status_kurzbz IN ('Student', 'Unterbrecher', 'Abbrecher', 'Diplomand', 'Absolvent')
AND studiengang.studiengang_kz < 10000
AND status.studiensemester_kurzbz = ?
AND NOT (status.orgform_kurzbz IS NULL AND studiengang.mischform = FALSE)
AND NOT EXISTS(
SELECT 1
FROM
lehre.tbl_studienplan
JOIN
lehre.tbl_studienordnung USING(studienordnung_id)
WHERE
tbl_studienplan.studienplan_id = stpl.studienplan_id
AND tbl_studienordnung.studiengang_kz = prestudent.studiengang_kz
AND tbl_studienplan.orgform_kurzbz = status.orgform_kurzbz)";
if (isset($studiengang_kz))
{
$qry .= " AND studiengang.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($prestudent_id))
{
$qry .= " AND prestudent.prestudent_id = ?";
$params[] = $prestudent_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
$qry .= "
ORDER BY student_uid";
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -6,18 +6,13 @@
abstract class PlausiChecker
{
protected $_ci; // code igniter instance
protected $_config; // configuration parameters for this plausicheck
protected $_db; // database for queries
public function __construct($configurationParams = null)
public function __construct()
{
$this->_ci =& get_instance(); // get code igniter instance
// set configuration
$this->_config = $configurationParams;
// get database for queries
$this->_db = new DB_Model();
// load libraries
$this->_ci->load->library('issues/PlausicheckLib'); // load plausicheck library
}
/**
@@ -13,20 +13,12 @@ class PrestudentMischformOhneOrgform extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiensemester_kurzbz = isset($params['studiensemester_kurzbz']) ? $params['studiensemester_kurzbz'] : null;
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$prestudentRes = $this->getPrestudentMischformOhneOrgform(
$studiensemester_kurzbz,
$studiengang_kz,
null,
$exkludierte_studiengang_kz
);
$prestudentRes = $this->_ci->plausichecklib->getPrestudentMischformOhneOrgform($studiensemester_kurzbz, $studiengang_kz);
if (isError($prestudentRes)) return $prestudentRes;
@@ -55,55 +47,4 @@ class PrestudentMischformOhneOrgform extends PlausiChecker
// return the results
return success($results);
}
/**
* Students in "mixed" Studiengang should have Orgform.
* @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param prestudent_id int if check is to be executed only for one prestudent
* @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
* @return success with prestudents or error
*/
public function getPrestudentMischformOhneOrgform(
$studiensemester_kurzbz,
$studiengang_kz = null,
$prestudent_id = null,
$exkludierte_studiengang_kz = null
) {
$params = array($studiensemester_kurzbz);
$qry = "
SELECT
pre.person_id, pre.prestudent_id, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz, status.studiensemester_kurzbz
FROM
public.tbl_prestudent pre
JOIN public.tbl_person USING(person_id)
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
JOIN public.tbl_studiengang stg USING(studiengang_kz)
WHERE
status.status_kurzbz IN ('Bewerber', 'Student')
AND stg.mischform
AND (status.orgform_kurzbz='' OR status.orgform_kurzbz IS NULL)
AND status.studiensemester_kurzbz=?";
if (isset($studiengang_kz))
{
$qry .= " AND stg.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($prestudent_id))
{
$qry .= " AND pre.prestudent_id = ?";
$params[] = $prestudent_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -13,14 +13,11 @@ class StgPrestudentUngleichStgStudent extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$prestudentRes = $this->getStgPrestudentUngleichStgStudent($studiengang_kz, null, $exkludierte_studiengang_kz);
$prestudentRes = $this->_ci->plausichecklib->getStgPrestudentUngleichStgStudent($studiengang_kz);
if (isError($prestudentRes)) return $prestudentRes;
@@ -43,48 +40,4 @@ class StgPrestudentUngleichStgStudent extends PlausiChecker
// return the results
return success($results);
}
/**
* Studiengang should be the same for prestudent and student.
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param prestudent_id int if check is to be executed only for one prestudent
* @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
* @return success with prestudents or error
*/
public function getStgPrestudentUngleichStgStudent($studiengang_kz = null, $prestudent_id = null, $exkludierte_studiengang_kz = null)
{
$params = array();
$qry = "
SELECT
pre.person_id, pre.prestudent_id, stg.oe_kurzbz prestudent_stg_oe_kurzbz, student_stg.oe_kurzbz student_stg_oe_kurzbz
FROM
public.tbl_prestudent pre
JOIN public.tbl_student stud USING(prestudent_id)
JOIN public.tbl_person pers USING(person_id)
JOIN public.tbl_studiengang stg ON pre.studiengang_kz = stg.studiengang_kz
JOIN public.tbl_studiengang student_stg ON stud.studiengang_kz = student_stg.studiengang_kz
WHERE
stud.studiengang_kz != pre.studiengang_kz";
if (isset($studiengang_kz))
{
$qry .= " AND stg.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($prestudent_id))
{
$qry .= " AND pre.prestudent_id = ?";
$params[] = $prestudent_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -13,14 +13,11 @@ class StgPrestudentUngleichStgStudienplan extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$prestudentRes = $this->getStgPrestudentUngleichStgStudienplan($studiengang_kz, null, null, $exkludierte_studiengang_kz);
$prestudentRes = $this->_ci->plausichecklib->getStgPrestudentUngleichStgStudienplan($studiengang_kz);
if (isError($prestudentRes)) return $prestudentRes;
@@ -43,62 +40,4 @@ class StgPrestudentUngleichStgStudienplan extends PlausiChecker
// return the results
return success($results);
}
/**
* Studiengang should be the same for prestudent and studienplan.
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param prestudent_id int if check is to be executed only for one prestudent
* @param studienordnung_id int if check is to be executed only for a certain studienordnung_id
* @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
* @return success with prestudents or error
*/
public function getStgPrestudentUngleichStgStudienplan(
$studiengang_kz = null,
$prestudent_id = null,
$studienordnung_id = null,
$exkludierte_studiengang_kz = null
) {
$params = array();
$qry = "
SELECT
DISTINCT ON (ps.prestudent_id) ps.person_id, ps.prestudent_id, stordnung.studienordnung_id,
stplan.bezeichnung AS studienplan, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz
FROM
public.tbl_prestudent ps
JOIN public.tbl_prestudentstatus USING(prestudent_id)
JOIN lehre.tbl_studienplan stplan USING(studienplan_id)
JOIN lehre.tbl_studienordnung stordnung USING(studienordnung_id)
JOIN public.tbl_person USING(person_id)
JOIN public.tbl_studiengang stg ON ps.studiengang_kz = stg.studiengang_kz
WHERE
ps.studiengang_kz<>stordnung.studiengang_kz
AND stg.melderelevant";
if (isset($studiengang_kz))
{
$qry .= " AND stg.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($prestudent_id))
{
$qry .= " AND ps.prestudent_id = ?";
$params[] = $prestudent_id;
}
if (isset($studienordnung_id))
{
$qry .= " AND stordnung.studienordnung_id = ?";
$params[] = $studienordnung_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -13,14 +13,11 @@ class StudentstatusNachAbbrecher extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$prestudentRes = $this->getStudentstatusNachAbbrecher($studiengang_kz, null, $exkludierte_studiengang_kz);
$prestudentRes = $this->_ci->plausichecklib->getStudentstatusNachAbbrecher($studiengang_kz);
if (isError($prestudentRes)) return $prestudentRes;
@@ -43,48 +40,4 @@ class StudentstatusNachAbbrecher extends PlausiChecker
// return the results
return success($results);
}
/**
* There shouldn't be any status after Abbrecher status.
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param prestudent_id int if check is to be executed only for one prestudent
* @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
* @return success with prestudents or error
*/
public function getStudentstatusNachAbbrecher($studiengang_kz = null, $prestudent_id = null, $exkludierte_studiengang_kz = null)
{
$params = array();
$qry = "
SELECT
prestudent.person_id, prestudent.prestudent_id, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz
FROM
public.tbl_student student
JOIN public.tbl_prestudent prestudent USING(prestudent_id)
JOIN public.tbl_prestudentstatus prestatus USING(prestudent_id)
JOIN public.tbl_studiengang stg ON prestudent.studiengang_kz = stg.studiengang_kz
WHERE
prestatus.status_kurzbz = 'Abbrecher'
AND get_rolle_prestudent(prestudent.prestudent_id, prestatus.studiensemester_kurzbz) <> 'Abbrecher'";
if (isset($studiengang_kz))
{
$qry .= " AND stg.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($prestudent_id))
{
$qry .= " AND prestudent.prestudent_id = ?";
$params[] = $prestudent_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -13,20 +13,12 @@ class StudienplanUngueltig extends PlausiChecker
{
$results = array();
// get parameters from config
$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
// pass parameters needed for plausicheck
$studiensemester_kurzbz = isset($params['studiensemester_kurzbz']) ? $params['studiensemester_kurzbz'] : null;
$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
// get all students failing the plausicheck
$prestudentRes = $this->getStudienplanUngueltig(
$studiensemester_kurzbz,
$studiengang_kz,
null,
$exkludierte_studiengang_kz
);
$prestudentRes = $this->_ci->plausichecklib->getStudienplanUngueltig($studiensemester_kurzbz, $studiengang_kz);
if (isError($prestudentRes)) return $prestudentRes;
@@ -56,71 +48,4 @@ class StudienplanUngueltig extends PlausiChecker
// return the results
return success($results);
}
/**
* Studienplan should be valid in current Ausbildungssemester of prestudent.
* @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
* @param studiengang_kz int if check is to be executed for certain Studiengang
* @param prestudent_id int if check is to be executed only for one prestudent
* @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
* @return success with prestudents or error
*/
public function getStudienplanUngueltig(
$studiensemester_kurzbz,
$studiengang_kz = null,
$prestudent_id = null,
$exkludierte_studiengang_kz = null
) {
$params = array($studiensemester_kurzbz);
$qry = "
SELECT
DISTINCT pre.person_id, pre.prestudent_id,
tbl_studienplan.bezeichnung AS studienplan,
status.status_kurzbz,
status.studiensemester_kurzbz,
status.ausbildungssemester,
stg.oe_kurzbz AS prestudent_stg_oe_kurzbz
FROM
public.tbl_prestudent pre
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
JOIN public.tbl_person USING(person_id)
JOIN lehre.tbl_studienplan USING(studienplan_id)
JOIN public.tbl_studiengang stg ON pre.studiengang_kz = stg.studiengang_kz
WHERE
status_kurzbz in('Student', 'Interessent','Bewerber','Aufgenommener')
AND NOT EXISTS (
SELECT
1
FROM
lehre.tbl_studienplan_semester
WHERE
studienplan_id=status.studienplan_id
AND tbl_studienplan_semester.semester = status.ausbildungssemester
AND tbl_studienplan_semester.studiensemester_kurzbz = status.studiensemester_kurzbz
)
AND status.studiensemester_kurzbz=?
AND pre.bismelden
AND stg.melderelevant";
if (isset($studiengang_kz))
{
$qry .= " AND stg.studiengang_kz = ?";
$params[] = $studiengang_kz;
}
if (isset($prestudent_id))
{
$qry .= " AND tbl_prestudent.prestudent_id = ?";
$params[] = $prestudent_id;
}
if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
{
$qry .= " AND stg.studiengang_kz NOT IN ?";
$params[] = $exkludierte_studiengang_kz;
}
return $this->_db->execReadOnlyQuery($qry, $params);
}
}
@@ -17,10 +17,10 @@ class CORE_INOUT_0007 implements IIssueResolvedChecker
$this->_ci =& get_instance(); // get code igniter instance
$this->_ci->load->library('issues/plausichecks/IncomingHeimatNationOesterreich');
$this->_ci->load->library('issues/PlausicheckLib');
// check if issue persists
$checkRes = $this->_ci->incomingheimatnationoesterreich->getIncomingHeimatNationOesterreich($params['studiensemester_kurzbz'], null, $params['issue_person_id']);
$checkRes = $this->_ci->plausichecklib->getIncomingHeimatNationOesterreich($params['studiensemester_kurzbz'], null, $params['issue_person_id']);
if (isError($checkRes)) return $checkRes;
@@ -3,7 +3,7 @@
if (! defined('BASEPATH')) exit('No direct script access allowed');
/**
* Incoming should have IN/OUT data entry.
* Incoming shouldn't have austrian home address.
*/
class CORE_INOUT_0008 implements IIssueResolvedChecker
{
@@ -14,10 +14,10 @@ class CORE_INOUT_0008 implements IIssueResolvedChecker
$this->_ci =& get_instance(); // get code igniter instance
$this->_ci->load->library('issues/plausichecks/IncomingOhneIoDatensatz');
$this->_ci->load->library('issues/PlausicheckLib');
// check if issue persists
$checkRes = $this->_ci->incomingohneiodatensatz->getIncomingOhneIoDatensatz(null, $params['prestudent_id']);
$checkRes = $this->_ci->plausichecklib->getIncomingOhneIoDatensatz(null, $params['prestudent_id']);
if (isError($checkRes)) return $checkRes;

Some files were not shown because too many files have changed in this diff Show More