Compare commits

..

1 Commits

Author SHA1 Message Date
ma0068 a60345e7c8 bugfix 2023-07-27 14:11:44 +02:00
395 changed files with 3694 additions and 54946 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'
];
});
*/
-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'
);
-8
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'
)
)
),
-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,11 @@ 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
// Loads the AuthLib and starts the authentication
$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;
}
}
@@ -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;
}
}
@@ -242,7 +242,7 @@ class approveAnrechnungDetail extends Auth_Controller
$empfehlungsanfrage_an = !isEmptyArray($result) ? implode(', ', array_column($result, 'fullname')) : '';
// Request Recommendation
if ($this->anrechnunglib->requestRecommendation($anrechnung_id))
if($this->anrechnunglib->requestRecommendation($anrechnung_id))
{
$retval[]= array(
'anrechnung_id' => $anrechnung_id,
@@ -254,23 +254,31 @@ class approveAnrechnungDetail extends Auth_Controller
);
}
// Output json to ajax
if ($empfehlungsanfrage_an == '')
{
$this->terminateWithJsonError(
"Empfehlung wurde nicht angefordert,\nDer LV sind keine LektorInnen zugeteilt."
);
}
/**
* 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 ($this->config->item('send_mail') === TRUE)
{
$this->_sendSanchoMailToLectors($anrechnung_id);
}
// Output json to ajax
return $this->outputJsonSuccess($retval);
}
// Output json to ajax
if (isEmptyArray($retval))
{
$this->terminateWithJsonError("Empfehlung wurde nicht angefordert");
$this->terminateWithJsonError(
"Empfehlung wurde nicht angefordert,\nDer LV sind keine LektorInnen zugeteilt."
);
}
else
{
// Output json to ajax
return $this->outputJsonSuccess($retval);
}
$this->terminateWithJsonError($this->p->t('ui', 'errorNichtAusgefuehrt'));
}
/**
@@ -249,6 +249,19 @@ class approveAnrechnungUebersicht extends Auth_Controller
}
}
/**
* Send mails
* 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 ($this->config->item('send_mail') === TRUE)
{
$this->_sendSanchoMail($retval);
}
}
// Output json to ajax
if (isEmptyArray($retval))
{
@@ -260,7 +273,7 @@ class approveAnrechnungUebersicht extends Auth_Controller
$this->terminateWithJsonError('Es wurden keine Empfehlungen angefordert');
}
$this->outputJsonSuccess($retval);
return $this->outputJsonSuccess($retval);
}
/**
@@ -111,8 +111,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 +121,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 +148,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 +172,7 @@ class requestAnrechnung extends Auth_Controller
$lehrveranstaltung_id,
$begruendung_id,
$lastInsert_dms_id,
$anmerkung,
$begruendung_ects,
$begruendung_lvinhalt
$anmerkung
);
if (isError($result))
@@ -312,21 +306,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)
@@ -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',
@@ -230,16 +228,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 +314,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 +359,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';
@@ -1545,7 +1526,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 +1533,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 +1583,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 +1611,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))
{
@@ -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;
}
+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>';
-4
View File
@@ -174,8 +174,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 = '';
@@ -896,8 +894,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
-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(
+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!!!
}
}
-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
+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;
@@ -85,12 +85,6 @@ class GbDatumWeitZurueck extends PlausiChecker
$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))
@@ -99,6 +93,12 @@ class GbDatumWeitZurueck extends PlausiChecker
$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);
}
}
@@ -1,69 +0,0 @@
<?php
namespace vertragsbestandteil;
use vertragsbestandteil\IValidation;
/**
* Description of AbstractBestandteil
*
* @author bambi
*/
abstract class AbstractBestandteil implements IValidation
{
protected $isvalid;
protected $validationerrors;
protected $modifiedcolumns;
protected $fromdb;
public function __construct()
{
$this->isvalid = false;
$this->validationerrors = array();
$this->modifiedcolumns = array();
$this->fromdb = false;
}
public function isDirty() {
return count($this->modifiedcolumns) > 0;
}
protected function markDirty($columnname, $old_value, $new_value) {
if( $this->fromdb ) {
// data comes from db dont check for changes
if( isset($this->modifiedcolumns[$columnname]) ) {
unset($this->modifiedcolumns[$columnname]);
}
return;
}
if( is_bool($new_value) && ($old_value !== $new_value) ) {
$this->modifiedcolumns[$columnname] = $columnname;
} else if($old_value != $new_value) {
$this->modifiedcolumns[$columnname] = $columnname;
}
}
public function isValid()
{
return $this->isvalid;
}
public function getValidationErrors()
{
return $this->validationerrors;
}
public function addValidationError($errormsg)
{
if( !in_array($errormsg, $this->validationerrors, true) )
{
$this->validationerrors[] = $errormsg;
}
$this->isvalid = false;
}
abstract public function hydrateByStdClass($data, $fromdb=false);
}
@@ -1,265 +0,0 @@
<?php
namespace vertragsbestandteil;
require_once __DIR__ . '/IValidation.php';
require_once __DIR__ . '/AbstractBestandteil.php';
use vertragsbestandteil\AbstractBestandteil;
use vertragsbestandteil\IValidation;
const TYPE_ECHT = 'echterdv';
const TYPE_STUDENTISCHE_HILFSKRAFT = 'studentischehilfskr';
const TYPE_FREI = 'freierdv';
const TYPE_EXTERN = 'externerlehrender';
const TYPE_GAST = 'gastlektor';
const TYPE_ECHT_FREI = 'echterfreier';
const TYPE_WERKVERTRAG = 'werkvertrag';
const TYPE_UEBERLASSUNG = 'ueberlassungsvertrag';
class Dienstverhaeltnis extends AbstractBestandteil {
protected $dienstverhaeltnis_id;
protected $mitarbeiter_uid;
protected $vertragsart_kurzbz;
protected $oe_kurzbz;
protected $checkoverlap;
protected $von;
protected $bis;
protected $insertamum;
protected $insertvon;
protected $updateamum;
protected $updatevon;
public function __construct()
{
parent::__construct();
$this->checkoverlap = true;
}
public function hydrateByStdClass($data, $fromdb=false)
{
$this->fromdb = $fromdb;
isset($data->dienstverhaeltnis_id) && $this->setDienstverhaeltnis_id($data->dienstverhaeltnis_id);
isset($data->mitarbeiter_uid) && $this->setMitarbeiter_uid($data->mitarbeiter_uid);
isset($data->vertragsart_kurzbz) && $this->setVertragsart_kurzbz($data->vertragsart_kurzbz);
isset($data->checkoverlap) && $this->setCheckoverlap($data->checkoverlap);
isset($data->oe_kurzbz) && $this->setOe_kurzbz($data->oe_kurzbz);
isset($data->von) && $this->setVon($data->von);
isset($data->bis) && $this->setBis($data->bis);
isset($data->insertamum) && $this->setInsertamum($data->insertamum);
isset($data->insertvon) && $this->setInsertvon($data->insertvon);
isset($data->updateamum) && $this->setUpdateamum($data->updateamum);
isset($data->updatevon) && $this->setUpdatevon($data->updatevon);
$this->fromdb = false;
}
public function toStdClass(): \stdClass
{
$tmp = array(
'dienstverhaeltnis_id' => $this->getDienstverhaeltnis_id(),
'mitarbeiter_uid' => $this->getMitarbeiter_uid(),
'vertragsart_kurzbz' => $this->getVertragsart_kurzbz(),
'oe_kurzbz' => $this->getOe_kurzbz(),
'von' => $this->getVon(),
'bis' => $this->getBis(),
'insertamum' => $this->getInsertamum(),
'insertvon' => $this->getInsertvon(),
'updateamum' => $this->getUpdateamum(),
'updatevon' => $this->getUpdatevon()
);
$tmp = array_filter($tmp, function($k) {
return in_array($k, $this->modifiedcolumns);
}, ARRAY_FILTER_USE_KEY);
return (object) $tmp;
}
public function __toString()
{
$txt = <<<EOTXT
dienstverhaeltnis_id: {$this->getDienstverhaeltnis_id()}
mitarbeiter_uid: {$this->getMitarbeiter_uid()}
vertragsart_kurzbz: {$this->getVertragsart_kurzbz()}
oe_kurzbz: {$this->getOe_kurzbz()}
von: {$this->getVon()}
bis: {$this->getBis()}
EOTXT;
return $txt;
}
public function getDienstverhaeltnis_id()
{
return $this->dienstverhaeltnis_id;
}
public function getMitarbeiter_uid()
{
return $this->mitarbeiter_uid;
}
public function getVertragsart_kurzbz()
{
return $this->vertragsart_kurzbz;
}
public function getOe_kurzbz()
{
return $this->oe_kurzbz;
}
public function getVon()
{
return $this->von;
}
public function getBis()
{
return $this->bis;
}
public function getInsertamum()
{
return $this->insertamum;
}
public function getInsertvon()
{
return $this->insertvon;
}
public function getUpdateamum()
{
return $this->updateamum;
}
public function getUpdatevon()
{
return $this->updatevon;
}
public function setDienstverhaeltnis_id($dienstverhaeltnis_id)
{
$this->markDirty('dienstverhaeltnis_id', $this->dienstverhaeltnis_id, $dienstverhaeltnis_id);
$this->dienstverhaeltnis_id = $dienstverhaeltnis_id;
return $this;
}
public function setMitarbeiter_uid($mitarbeiter_uid)
{
$this->markDirty('mitarbeiter_uid', $this->mitarbeiter_uid, $mitarbeiter_uid);
$this->mitarbeiter_uid = $mitarbeiter_uid;
return $this;
}
public function setVertragsart_kurzbz($vertragsart_kurzbz)
{
$this->markDirty('vertragsart_kurzbz', $this->vertragsart_kurzbz, $vertragsart_kurzbz);
$this->vertragsart_kurzbz = $vertragsart_kurzbz;
return $this;
}
public function setCheckoverlap(bool $checkoverlap)
{
$this->checkoverlap = $checkoverlap;
}
public function setOe_kurzbz($oe_kurzbz)
{
$this->markDirty('oe_kurzbz', $this->oe_kurzbz, $oe_kurzbz);
$this->oe_kurzbz = $oe_kurzbz;
return $this;
}
public function setVon($von)
{
$this->markDirty('von', $this->von, $von);
$this->von = $von;
return $this;
}
public function setBis($bis)
{
$this->markDirty('bis', $this->bis, $bis);
$this->bis = $bis;
return $this;
}
public function setInsertamum($insertamum)
{
$this->markDirty('insertamum', $this->insertamum, $insertamum);
$this->insertamum = $insertamum;
return $this;
}
public function setInsertvon($insertvon)
{
$this->markDirty('insertvon', $this->insertvon, $insertvon);
$this->insertvon = $insertvon;
return $this;
}
public function setUpdateamum($updateamum)
{
$this->markDirty('updateamum', $this->updateamum, $updateamum);
$this->updateamum = $updateamum;
return $this;
}
public function setUpdatevon($updatevon)
{
$this->markDirty('updatevon', $this->updatevon, $updatevon);
$this->updatevon = $updatevon;
return $this;
}
public function validate() {
//do Validation here
$ci = get_instance();
$ci->load->library('vertragsbestandteil/VertragsbestandteilLib',
null, 'VertragsbestandteilLib');
if( empty($this->mitarbeiter_uid) ) {
$this->validationerrors[] = 'Mitarbeiter_UID fehlt.';
}
if( empty($this->oe_kurzbz) ) {
$this->validationerrors[] = 'Unternehmen fehlt.';
}
if( empty($this->vertragsart_kurzbz) ) {
$this->validationerrors[] = 'Vertragsart fehlt.';
}
$von = \DateTimeImmutable::createFromFormat('Y-m-d', $this->von);
$bis = \DateTimeImmutable::createFromFormat('Y-m-d', $this->bis);
if( false === $von ) {
$this->validationerrors[] = 'Beginn muss ein gültiges Datum sein.';
}
if( $this->bis !== null && $bis === false ) {
$this->validationerrors[] = 'Ende muss ein gültiges Datum oder leer sein.';
}
if( $this-> bis !== null && $von && $bis && $von > $bis ) {
$this->validationerrors[] = 'Das Beginndatum muss vor dem Endedatum liegen.';
}
if( $this->checkoverlap && !(in_array($this->vertragsart_kurzbz, array('werkvertrag', 'studentischehilfskr')) )
&& $ci->VertragsbestandteilLib->isOverlappingExistingDV($this) )
{
$this->validationerrors[] = 'Es existiert bereits ein überlappendes Dienstverhältnis';
}
// return status after Validation
if( count($this->validationerrors) > 0 ) {
$this->isvalid = false;
} else {
$this->isvalid = true;
}
return $this->isvalid;
}
}
@@ -1,360 +0,0 @@
<?php
namespace vertragsbestandteil;
use vertragsbestandteil\AbstractBestandteil;
use DateTimeImmutable;
/**
* Salary always depends on employment (Dienstverhältnis) and optionally on part of contract (Vetragsbestandteil)
*/
class Gehaltsbestandteil extends AbstractBestandteil implements \JsonSerializable
{
protected $gehaltsbestandteil_id;
protected $dienstverhaeltnis_id;
protected $vertragsbestandteil_id;
protected $gehaltstyp_kurzbz;
protected $von;
protected $bis;
protected $anmerkung;
protected $grundbetrag;
protected $betrag_valorisiert;
protected $valorisierungssperre;
protected $valorisierung;
protected $auszahlungen;
protected $insertamum;
protected $insertvon;
protected $updateamum;
protected $updatevon;
public function __construct()
{
parent::__construct();
}
public function hydrateByStdClass($data, $fromdb=false)
{
$this->fromdb = $fromdb;
isset($data->gehaltsbestandteil_id) && $this->setGehaltsbestandteil_id($data->gehaltsbestandteil_id);
isset($data->dienstverhaeltnis_id) && $this->setDienstverhaeltnis_id($data->dienstverhaeltnis_id);
isset($data->vertragsbestandteil_id) && $this->setVertragsbestandteil_id($data->vertragsbestandteil_id);
isset($data->gehaltstyp_kurzbz) && $this->setGehaltstyp_kurzbz($data->gehaltstyp_kurzbz);
isset($data->von) && $this->setVon($data->von);
isset($data->bis) && $this->setBis($data->bis);
isset($data->anmerkung) && $this->setAnmerkung($data->anmerkung);
isset($data->grundbetrag) && $this->setGrundbetrag($data->grundbetrag);
isset($data->betrag_valorisiert) && $this->setBetrag_valorisiert($data->betrag_valorisiert);
isset($data->valorisierungssperre) && $this->setValorisierungssperre($data->valorisierungssperre);
isset($data->valorisierung) && $this->setValorisierung($data->valorisierung);
isset($data->auszahlungen) && $this->setAuszahlungen($data->auszahlungen);
isset($data->insertamum) && $this->setInsertamum($data->insertamum);
isset($data->insertvon) && $this->setInsertvon($data->insertvon);
isset($data->updateamum) && $this->setUpdateamum($data->updateamum);
isset($data->updatevon) && $this->setUpdatevon($data->updatevon);
$this->fromdb = false;
}
public function getGehaltsbestandteil_id()
{
return $this->gehaltsbestandteil_id;
}
public function getDienstverhaeltnis_id()
{
return $this->dienstverhaeltnis_id;
}
public function getVertragsbestandteil_id()
{
return $this->vertragsbestandteil_id;
}
public function getGehaltstyp_kurzbz()
{
return $this->gehaltstyp_kurzbz;
}
public function getVon()
{
return $this->von;
}
public function getBis()
{
return $this->bis;
}
public function getVonDateTime()
{
return $this->toDateTime($this->von);
}
public function getBisDateTime()
{
return $this->toDateTime($this->bis);
}
protected function toDateTime($d) {
if ($d == null) return null;
return new DateTimeImmutable($d);
}
public function getAnmerkung()
{
return $this->anmerkung;
}
public function getGrundbetrag()
{
return $this->grundbetrag;
}
public function getBetrag_valorisiert()
{
return $this->betrag_valorisiert;
}
public function getValorisierungssperre()
{
return $this->valorisierungssperre;
}
public function getValorisierung()
{
return $this->valorisierung;
}
public function getAuszahlungen()
{
return $this->auszahlungen;
}
public function getInsertamum()
{
return $this->insertamum;
}
public function getInsertvon()
{
return $this->insertvon;
}
public function getUpdateamum()
{
return $this->updateamum;
}
public function getUpdatevon()
{
return $this->updatevon;
}
public function setGehaltsbestandteil_id($gehaltsbestandteil_id)
{
$this->markDirty('gehaltsbestandteil_id', $this->gehaltsbestandteil_id, $gehaltsbestandteil_id);
$this->gehaltsbestandteil_id = $gehaltsbestandteil_id;
return $this;
}
public function setDienstverhaeltnis_id($dienstverhaeltnis_id)
{
$this->markDirty('dienstverhaeltnis_id', $this->dienstverhaeltnis_id, $dienstverhaeltnis_id);
$this->dienstverhaeltnis_id = $dienstverhaeltnis_id;
return $this;
}
public function setVertragsbestandteil_id($vertragsbestandteil_id)
{
$this->markDirty('vertragsbestandteil_id', $this->vertragsbestandteil_id, $vertragsbestandteil_id);
$this->vertragsbestandteil_id = $vertragsbestandteil_id;
return $this;
}
public function setGehaltstyp_kurzbz($gehaltstyp_kurzbz)
{
$this->markDirty('gehaltstyp_kurzbz', $this->gehaltstyp_kurzbz, $gehaltstyp_kurzbz);
$this->gehaltstyp_kurzbz = $gehaltstyp_kurzbz;
return $this;
}
public function setVon($von)
{
$this->markDirty('von', $this->von, $von);
$this->von = $von;
return $this;
}
public function setBis($bis)
{
$this->markDirty('bis', $this->bis, $bis);
$this->bis = $bis;
return $this;
}
public function setAnmerkung($anmerkung)
{
$this->markDirty('anmerkung', $this->anmerkung, $anmerkung);
$this->anmerkung = $anmerkung;
return $this;
}
public function setGrundbetrag($grundbetrag)
{
$this->markDirty('grundbetrag', $this->grundbetrag, $grundbetrag);
$this->grundbetrag = $grundbetrag;
return $this;
}
public function setBetrag_valorisiert($betrag_valorisiert)
{
$this->markDirty('betrag_valorisiert', $this->betrag_valorisiert, $betrag_valorisiert);
$this->betrag_valorisiert = $betrag_valorisiert;
return $this;
}
public function setValorisierungssperre($valorisierungssperre)
{
$this->markDirty('valorisierungssperre', $this->valorisierungssperre, $valorisierungssperre);
$this->valorisierungssperre = $valorisierungssperre;
return $this;
}
public function setValorisierung($valorisierung)
{
$this->markDirty('valorisierung', $this->valorisierung, $valorisierung);
$this->valorisierung = $valorisierung;
return $this;
}
public function setAuszahlungen($auszahlungen)
{
$this->markDirty('auszahlungen', $this->auszahlungen, $auszahlungen);
$this->auszahlungen = $auszahlungen;
return $this;
}
public function setInsertamum($insertamum)
{
$this->markDirty('insertamum', $this->insertamum, $insertamum);
$this->insertamum = $insertamum;
return $this;
}
public function setInsertvon($insertvon)
{
$this->markDirty('insertvon', $this->insertvon, $insertvon);
$this->insertvon = $insertvon;
return $this;
}
public function setUpdateamum($updateamum)
{
$this->markDirty('updateamum', $this->updateamum, $updateamum);
$this->updateamum = $updateamum;
return $this;
}
public function setUpdatevon($updatevon)
{
$this->markDirty('updatevon', $this->updatevon, $updatevon);
$this->updatevon = $updatevon;
return $this;
}
public function jsonSerialize()
{
$vars = get_object_vars($this);
unset($vars['CI']);
return $vars;
}
public function toStdClass(): \stdClass
{
$tmp = array(
'gehaltsbestandteil_id' => $this->getGehaltsbestandteil_id(),
'dienstverhaeltnis_id' => $this->getDienstverhaeltnis_id(),
'vertragsbestandteil_id' => $this->getVertragsbestandteil_id(),
'gehaltstyp_kurzbz' => $this->getGehaltstyp_kurzbz(),
'von' => $this->getVon(),
'bis' => $this->getBis(),
'anmerkung' => $this->getAnmerkung(),
'grundbetrag' => $this->getGrundbetrag(),
'betrag_valorisiert' => $this->getBetrag_valorisiert(),
'valorisierungssperre' => $this->getValorisierungssperre(),
'valorisierung' => $this->getValorisierung(),
'auszahlungen' => $this->getAuszahlungen(),
'insertamum' => $this->getInsertamum(),
'insertvon' => $this->getInsertvon(),
'updateamum' => $this->getUpdateamum(),
'updatevon' => $this->getUpdatevon()
);
$tmp = array_filter($tmp, function($k) {
return in_array($k, $this->modifiedcolumns);
}, ARRAY_FILTER_USE_KEY);
return (object) $tmp;
}
public function __toString()
{
$txt = <<<EOTXT
gehaltsbestandteil_id: {$this->getGehaltsbestandteil_id()}
dienstverhaeltnis_id: {$this->getDienstverhaeltnis_id()}
vertragsbestandteil_id: {$this->getVertragsbestandteil_id()}
gehaltstyp_kurzbz: {$this->getGehaltstyp_kurzbz()}
von: {$this->getVon()}
bis: {$this->getBis()}
anmerkung: {$this->getAnmerkung()}
grundbetrag: {$this->getGrundbetrag()}
betrag_valorisiert: {$this->getBetrag_valorisiert()}
valorisierungssperre: {$this->getValorisierungssperre()}
valorisierung: {$this->getValorisierung()}
auszahlungen: {$this->getAuszahlungen()}
insertamum: {$this->getInsertamum()}
insertvon: {$this->getInsertvon()}
updateamum: {$this->getUpdateamum()}
updatevon: {$this->getUpdatevon()}
EOTXT;
return $txt;
}
public function validate() {
//do Validation here
if( empty($this->gehaltstyp_kurzbz) )
{
$this->validationerrors[] = "Ein Gehaltstyp muss ausgewählt sein.";
}
if( empty($this->grundbetrag) )
{
$this->validationerrors[] = "Betrag fehlt.";
}
$von = \DateTimeImmutable::createFromFormat('Y-m-d', $this->von);
$bis = \DateTimeImmutable::createFromFormat('Y-m-d', $this->bis);
if( false === $von ) {
$this->validationerrors[] = 'Beginn muss ein gültiges Datum sein.';
}
if( $this->bis !== null && $bis === false ) {
$this->validationerrors[] = 'Ende muss ein gültiges Datum oder leer sein.';
}
if( $this-> bis !== null && $von && $bis && $von > $bis ) {
$this->validationerrors[] = 'Das Beginndatum muss vor dem Endedatum liegen.';
}
// return status after Validation
if( count($this->validationerrors) > 0 ) {
$this->isvalid = false;
} else {
$this->isvalid = true;
}
return $this->isvalid;
}
}
@@ -1,149 +0,0 @@
<?php
require_once __DIR__ . '/IValidation.php';
require_once __DIR__ . '/AbstractBestandteil.php';
require_once __DIR__ . '/Gehaltsbestandteil.php';
use vertragsbestandteil\Gehaltsbestandteil;
/**
* Description of GehaltsbestandteilLib
*
* @author bambi
*/
class GehaltsbestandteilLib
{
protected $CI;
/** @var Gehaltsbestandteil_model */
protected $GehaltsbestandteilModel;
protected $loggedInUser;
public function __construct()
{
$this->loggedInUser = getAuthUID();
$this->CI = get_instance();
$this->CI->load->model('vertragsbestandteil/Gehaltsbestandteil_model',
'GehaltsbestandteilModel');
$this->CI->load->library('extensions/FHC-Core-Personalverwaltung/abrechnung/GehaltsLib');
$this->GehaltsbestandteilModel = $this->CI->GehaltsbestandteilModel;
}
public function fetchGehaltsbestandteile($dienstverhaeltnis_id, $stichtag=null, $includefuture=false)
{
return $this->GehaltsbestandteilModel->getGehaltsbestandteile($dienstverhaeltnis_id, $stichtag, $includefuture);
}
public function fetchGehaltsbestandteil($gehaltsbestandteil_id)
{
return $this->GehaltsbestandteilModel->getGehaltsbestandteil($gehaltsbestandteil_id);
}
public function storeGehaltsbestandteile($gehaltsbestandteile)
{
foreach( $gehaltsbestandteile as $gehaltsbestandteil )
{
$this->storeGehaltsbestandteil($gehaltsbestandteil);
}
}
public function storeGehaltsbestandteil(Gehaltsbestandteil $gehaltsbestandteil)
{
try
{
$this->setUIDtoPGSQL();
if( intval($gehaltsbestandteil->getGehaltsbestandteil_id()) > 0 )
{
$this->updateGehaltsbestandteil($gehaltsbestandteil);
}
else
{
$this->insertGehaltsbestandteil($gehaltsbestandteil);
}
}
catch (Exception $ex)
{
log_message('debug', "Storing Gehaltsbestandteil failed. " . $ex->getMessage());
throw new Exception('Storing Gehaltsbestandteil failed.');
}
}
protected function insertGehaltsbestandteil(Gehaltsbestandteil $gehaltsbestandteil)
{
$gehaltsbestandteil->setInsertvon($this->loggedInUser)
->setInsertamum(strftime('%Y-%m-%d %H:%M:%S'));
$ret = $this->GehaltsbestandteilModel->insert($gehaltsbestandteil->toStdClass(),
$this->GehaltsbestandteilModel->getEncryptedColumns());
if( hasData($ret) )
{
$gehaltsbestandteil->setGehaltsbestandteil_id(getData($ret));
}
else
{
throw new Exception('error inserting gehaltsbestandteil');
}
}
protected function updateGehaltsbestandteil(Gehaltsbestandteil $gehaltsbestandteil)
{
if(!$gehaltsbestandteil->isDirty()) {
return;
}
$gehaltsbestandteil->setUpdatevon($this->loggedInUser)
->setUpdateamum(strftime('%Y-%m-%d %H:%M:%S'));
$ret = $this->GehaltsbestandteilModel->update($gehaltsbestandteil->getGehaltsbestandteil_id(),
$gehaltsbestandteil->toStdClass(),
$this->GehaltsbestandteilModel->getEncryptedColumns());
if(isError($ret) )
{
throw new Exception('error updating gehaltsbestandteil');
}
}
public function deleteGehaltsbestandteile($gehaltsbestandteile)
{
foreach( $gehaltsbestandteile as $gehaltsbestandteil )
{
$this->deleteGehaltsbestandteil($gehaltsbestandteil);
}
}
public function deleteGehaltsbestandteil(Gehaltsbestandteil $gehaltsbestandteil)
{
$this->setUIDtoPGSQL();
// delete Gehaltsabrechnung
$ret = $this->CI->gehaltslib->deleteAbrechnung($gehaltsbestandteil);
//
$ret = $this->GehaltsbestandteilModel->delete($gehaltsbestandteil->getGehaltsbestandteil_id());
if (isError($ret))
{
throw new Exception('error deleting gehaltsbestandteil');
}
}
public function endGehaltsbestandteil(Gehaltsbestandteil $gehaltsbestandteil, $enddate)
{
$this->setUIDtoPGSQL();
if( $gehaltsbestandteil->getBis() !== null && $gehaltsbestandteil->getBis() < $enddate )
{
return;
}
$gehaltsbestandteil->setBis($enddate);
$this->updateGehaltsbestandteil($gehaltsbestandteil);
}
protected function setUIDtoPGSQL() {
$ret = $this->GehaltsbestandteilModel
->execReadOnlyQuery('SET LOCAL pv21.uid TO \''
. $this->loggedInUser . '\'');
if(isError($ret))
{
throw new Exception('error setting uid to pgsql');
}
}
}
@@ -1,18 +0,0 @@
<?php
namespace vertragsbestandteil;
/**
* Description of IValidation
*
* @author bambi
*/
interface IValidation
{
public function isValid();
public function getValidationErrors();
public function validate();
public function addValidationError($errormsg);
}
@@ -1,111 +0,0 @@
<?php
namespace vertragsbestandteil;
use vertragsbestandteil\Vertragsbestandteil;
use vertragsbestandteil\VertragsbestandteilFreitext;
/**
* Description of OverlapChecker
*
* @author bambi
*/
class OverlapChecker
{
protected $CI;
/**
* @var Vertragsbestandteil_model
*/
protected $VertragsbestandteilModel;
/**
* @var VertragsbestandteilFreitext_model
*/
protected $VertragsbestandteilFreitextModel;
/**
* @var VertragsbestandteilTyp_model
*/
protected $VertragsbestandteilTypModel;
/**
* @var VertragsbestandteilFreitexttyp_model
*/
protected $VertragsbestandteilFreitexttypModel;
protected static $instance = null;
public static function getInstance()
{
if( null === self::$instance )
{
self::$instance = new OverlapChecker();
}
return self::$instance;
}
private function __construct()
{
$this->CI = get_instance();
$this->CI->load->model('vertragsbestandteil/Vertragsbestandteil_model',
'VertragsbestandteilModel');
$this->VertragsbestandteilModel = $this->CI->VertragsbestandteilModel;
$this->CI->load->model('vertragsbestandteil/VertragsbestandteilFreitext_model',
'VertragsbestandteilFreitextModel');
$this->VertragsbestandteilFreitextModel = $this->CI->VertragsbestandteilFreitextModel;
$this->CI->load->model('vertragsbestandteil/Vertragsbestandteiltyp_model',
'VertragsbestandteilTypModel');
$this->VertragsbestandteilTypModel = $this->CI->VertragsbestandteilTypModel;
$this->CI->load->model('vertragsbestandteil/VertragsbestandteilFreitexttyp_model',
'VertragsbestandteilFreitexttypModel');
$this->VertragsbestandteilFreitexttypModel = $this->CI->VertragsbestandteilFreitexttypModel;
}
public function overlapsVB(Vertragsbestandteil $vb)
{
$result = $this->VertragsbestandteilTypModel->load($vb->getVertragsbestandteiltyp_kurzbz());
if( null === ($vertragsbestandteiltyp = getData($result)) )
{
throw new Exception('vertragsbestandteiltyp: '
. $vb->getVertragsbestandteiltyp_kurzbz() . ' not found.');
}
if( true === $vertragsbestandteiltyp[0]->ueberlappend )
{
// vertragsbestandteiltyp can overlap
return false;
}
if( $this->VertragsbestandteilModel->countOverlappingVBsOfSameType($vb) === 0 )
{
return false;
}
else
{
return true;
}
}
public function overlapsFreitext(VertragsbestandteilFreitext $vbft)
{
$result = $this->VertragsbestandteilFreitexttypModel->load($vbft->getFreitexttypKurzbz());
if( null === ($vertragsbestandteilfreitexttyp = getData($result)) )
{
throw new Exception('vertragsbestandteilfreitexttyp: '
. $vbft->getFreitexttypKurzbz() . ' not found.');
}
if( true === $vertragsbestandteilfreitexttyp[0]->ueberlappend )
{
// freitexttyp can overlap
return false;
}
if( $this->VertragsbestandteilFreitextModel->countOverlappingVBFreitextsOfSameType($vbft) === 0 )
{
return false;
}
else
{
return true;
}
}
private function __clone() {}
}
@@ -1,265 +0,0 @@
<?php
namespace vertragsbestandteil;
use vertragsbestandteil\AbstractBestandteil;
/**
* Description of Vertragsbestandteil
*
* @author bambi
*/
abstract class Vertragsbestandteil extends AbstractBestandteil implements \JsonSerializable
{
protected $vertragsbestandteil_id;
protected $dienstverhaeltnis_id;
protected $von;
protected $bis;
protected $vertragsbestandteiltyp_kurzbz;
protected $insertamum;
protected $insertvon;
protected $updateamum;
protected $updatevon;
protected $gehaltsbestandteile;
public function __construct()
{
parent::__construct();
$this->gehaltsbestandteile = array();
}
public function hydrateByStdClass($data, $fromdb=false)
{
$this->fromdb = $fromdb;
isset($data->vertragsbestandteil_id) && $this->setVertragsbestandteil_id($data->vertragsbestandteil_id);
isset($data->dienstverhaeltnis_id) && $this->setDienstverhaeltnis_id($data->dienstverhaeltnis_id);
isset($data->von) && $this->setVon($data->von);
isset($data->bis) && $this->setBis($data->bis);
isset($data->vertragsbestandteiltyp_kurzbz) && $this->setVertragsbestandteiltyp_kurzbz($data->vertragsbestandteiltyp_kurzbz);
isset($data->insertamum) && $this->setInsertamum($data->insertamum);
isset($data->insertvon) && $this->setInsertvon($data->insertvon);
isset($data->updateamum) && $this->setUpdateamum($data->updateamum);
isset($data->updatevon) && $this->setUpdatevon($data->updatevon);
$this->fromdb = false;
}
public function addGehaltsbestandteil(Gehaltsbestandteil $gehaltsbestandteil)
{
$gehaltsbestandteil->setDienstverhaeltnis_id($this->getDienstverhaeltnis_id());
$gehaltsbestandteil->setVertragsbestandteil_id($this->getVertragsbestandteil_id());
$this->gehaltsbestandteile[] = $gehaltsbestandteil;
return $this;
}
public function getGehaltsbestandteile()
{
return $this->gehaltsbestandteile;
}
public function getVertragsbestandteil_id()
{
return $this->vertragsbestandteil_id;
}
public function getDienstverhaeltnis_id()
{
return $this->dienstverhaeltnis_id;
}
public function getVon()
{
return $this->von;
}
public function getBis()
{
return $this->bis;
}
public function getVertragsbestandteiltyp_kurzbz()
{
return $this->vertragsbestandteiltyp_kurzbz;
}
public function getInsertamum()
{
return $this->insertamum;
}
public function getInsertvon()
{
return $this->insertvon;
}
public function getUpdateamum()
{
return $this->updateamum;
}
public function getUpdatevon()
{
return $this->updatevon;
}
public function setGehaltsbestandteile($gehaltsbestandteile)
{
$this->gehaltsbestandteile = $gehaltsbestandteile;
return $this;
}
public function setVertragsbestandteil_id($vertragsbestandteil_id)
{
$this->markDirty('vertragsbestandteil_id', $this->vertragsbestandteil_id, $vertragsbestandteil_id);
$this->vertragsbestandteil_id = $vertragsbestandteil_id;
foreach ($this->gehaltsbestandteile as $gehaltsbestandteil)
{
$gehaltsbestandteil->setVertragsbestandteil_id($vertragsbestandteil_id);
}
return $this;
}
public function setDienstverhaeltnis_id($dienstverhaeltnis_id)
{
$this->markDirty('dienstverhaeltnis_id', $this->dienstverhaeltnis_id, $dienstverhaeltnis_id);
$this->dienstverhaeltnis_id = $dienstverhaeltnis_id;
foreach ($this->gehaltsbestandteile as $gehaltsbestandteil)
{
$gehaltsbestandteil->setDienstverhaeltnis_id($dienstverhaeltnis_id);
}
return $this;
}
public function setVon($von)
{
$this->markDirty('von', $this->von, $von);
$this->von = $von;
return $this;
}
public function setBis($bis)
{
$this->markDirty('bis', $this->bis, $bis);
$this->bis = $bis;
return $this;
}
public function setVertragsbestandteiltyp_kurzbz($vertragsbestandteiltyp_kurzbz)
{
$this->markDirty('vertragsbestandteiltyp_kurzbz', $this->vertragsbestandteiltyp_kurzbz, $vertragsbestandteiltyp_kurzbz);
$this->vertragsbestandteiltyp_kurzbz = $vertragsbestandteiltyp_kurzbz;
return $this;
}
public function setInsertamum($insertamum)
{
$this->markDirty('insertamum', $this->insertamum, $insertamum);
$this->insertamum = $insertamum;
return $this;
}
public function setInsertvon($insertvon)
{
$this->markDirty('insertvon', $this->insertvon, $insertvon);
$this->insertvon = $insertvon;
return $this;
}
public function setUpdateamum($updateamum)
{
$this->markDirty('updateamum', $this->updateamum, $updateamum);
$this->updateamum = $updateamum;
return $this;
}
public function setUpdatevon($updatevon)
{
$this->markDirty('updatevon', $this->updatevon, $updatevon);
$this->updatevon = $updatevon;
return $this;
}
public function baseToStdClass() {
$tmp = array(
'vertragsbestandteil_id' => $this->getVertragsbestandteil_id(),
'dienstverhaeltnis_id' => $this->getDienstverhaeltnis_id(),
'von' => $this->getVon(),
'bis' => $this->getBis(),
'vertragsbestandteiltyp_kurzbz' => $this->getVertragsbestandteiltyp_kurzbz(),
'insertamum' => $this->getInsertamum(),
'insertvon' => $this->getInsertvon(),
'updateamum' => $this->getUpdateamum(),
'updatevon' => $this->getUpdatevon(),
);
$tmp = array_filter($tmp, function($k) {
return in_array($k, $this->modifiedcolumns);
}, ARRAY_FILTER_USE_KEY);
return (object) $tmp;
}
public function jsonSerialize()
{
$vars = get_object_vars($this);
unset($vars['CI']);
// TODO cleanup workaroung for vb freitext where db column is anmerkung and formfield is freitext
if( isset($vars['anmerkung']) ) {
$vars['freitext'] = $vars['anmerkung'];
}
return $vars;
}
public function __toString()
{
return <<<EOTXT
vertragsbestandteil_id: {$this->getVertragsbestandteil_id()}
dienstverhaeltnis_id: {$this->getDienstverhaeltnis_id()}
von: {$this->getVon()}
bis: {$this->getBis()}
vertragsbestandteiltyp_kurzbz: {$this->getVertragsbestandteiltyp_kurzbz()}
insertamum: {$this->getInsertamum()}
insertvon: {$this->getInsertvon()}
updateamum: {$this->getUpdateamum()}
updatevon: {$this->getUpdatevon()}
EOTXT;
}
public function beforePersist() {
// can be overridden in childs
}
public function afterDelete() {
// can be overridden in childs
}
public function validate() {
$von = \DateTimeImmutable::createFromFormat('Y-m-d', $this->von);
$bis = \DateTimeImmutable::createFromFormat('Y-m-d', $this->bis);
if( false === $von ) {
$this->validationerrors[] = 'Beginn muss ein gültiges Datum sein.';
}
if( $this->bis !== null && $bis === false ) {
$this->validationerrors[] = 'Ende muss ein gültiges Datum oder leer sein.';
}
if( $this-> bis !== null && $von && $bis && $von > $bis ) {
$this->validationerrors[] = 'Das Beginndatum muss vor dem Endedatum liegen.';
}
if( count($this->validationerrors) > 0 ) {
$this->isvalid = false;
} else {
$this->isvalid = true;
}
return $this->isvalid;
}
public abstract function toStdClass();
}
@@ -1,137 +0,0 @@
<?php
namespace vertragsbestandteil;
use Exception;
use vertragsbestandteil\VertragsbestandteilStunden;
/**
* Description of VertragsbestandteilFactory
*
* @author bambi
*/
class VertragsbestandteilFactory
{
const VERTRAGSBESTANDTEIL_STUNDEN = 'stunden';
const VERTRAGSBESTANDTEIL_FUNKTION = 'funktion';
const VERTRAGSBESTANDTEIL_GEHALT = 'gehalt';
const VERTRAGSBESTANDTEIL_FREITEXT = 'freitext';
const VERTRAGSBESTANDTEIL_KARENZ = 'karenz';
const VERTRAGSBESTANDTEIL_BEFRISTUNG = 'befristung';
const VERTRAGSBESTANDTEIL_KUENDIGUNGSFRIST = 'kuendigungsfrist';
const VERTRAGSBESTANDTEIL_KV = 'kv';
const VERTRAGSBESTANDTEIL_URLAUBSANSPRUCH = 'urlaubsanspruch';
const VERTRAGSBESTANDTEIL_ZEITAUFZEICHNUNG = 'zeitaufzeichnung';
const VERTRAGSBESTANDTEIL_LEHRE = 'lehre';
public static function getVertragsbestandteil($data, $fromdb=false)
{
$vertragsbestandteiltyp_kurzbz = isset($data->vertragsbestandteiltyp_kurzbz)
? $data->vertragsbestandteiltyp_kurzbz : false;
if( false === $vertragsbestandteiltyp_kurzbz )
{
throw new Exception('Missing Parameter vertragsbestandteiltyp_kurzbz');
}
$vertragsbestandteil = null;
switch ($vertragsbestandteiltyp_kurzbz)
{
case self::VERTRAGSBESTANDTEIL_FREITEXT:
$vertragsbestandteil = new VertragsbestandteilFreitext();
$vertragsbestandteil->hydrateByStdClass($data, $fromdb);
break;
case self::VERTRAGSBESTANDTEIL_FUNKTION:
$vertragsbestandteil = new VertragsbestandteilFunktion();
$vertragsbestandteil->hydrateByStdClass($data, $fromdb);
break;
case self::VERTRAGSBESTANDTEIL_KARENZ:
$vertragsbestandteil = new VertragsbestandteilKarenz();
$vertragsbestandteil->hydrateByStdClass($data, $fromdb);
break;
case self::VERTRAGSBESTANDTEIL_KUENDIGUNGSFRIST:
$vertragsbestandteil = new VertragsbestandteilKuendigungsfrist();
$vertragsbestandteil->hydrateByStdClass($data, $fromdb);
break;
case self::VERTRAGSBESTANDTEIL_STUNDEN:
$vertragsbestandteil = new VertragsbestandteilStunden();
$vertragsbestandteil->hydrateByStdClass($data, $fromdb);
break;
case self::VERTRAGSBESTANDTEIL_URLAUBSANSPRUCH:
$vertragsbestandteil = new VertragsbestandteilUrlaubsanspruch();
$vertragsbestandteil->hydrateByStdClass($data, $fromdb);
break;
case self::VERTRAGSBESTANDTEIL_ZEITAUFZEICHNUNG:
$vertragsbestandteil = new VertragsbestandteilZeitaufzeichnung();
$vertragsbestandteil->hydrateByStdClass($data, $fromdb);
break;
default:
throw new Exception('Unknown vertragsbestandteiltyp_kurzbz '
. $vertragsbestandteiltyp_kurzbz);
}
return $vertragsbestandteil;
}
public static function getVertragsbestandteilDBModel($vertragsbestandteil_kurzbz): \DB_model
{
$CI = get_instance();
$vertragsbestandteildbmodel = null;
switch ($vertragsbestandteil_kurzbz)
{
case self::VERTRAGSBESTANDTEIL_FREITEXT:
$CI->load->model('vertragsbestandteil/VertragsbestandteilFreitext_model',
'VertragsbestandteilFreitext_model');
$vertragsbestandteildbmodel = $CI->VertragsbestandteilFreitext_model;
break;
case self::VERTRAGSBESTANDTEIL_FUNKTION:
$CI->load->model('vertragsbestandteil/VertragsbestandteilFunktion_model',
'VertragsbestandteilFunktion_model');
$vertragsbestandteildbmodel = $CI->VertragsbestandteilFunktion_model;
break;
case self::VERTRAGSBESTANDTEIL_KARENZ:
$CI->load->model('vertragsbestandteil/VertragsbestandteilKarenz_model',
'VertragsbestandteilKarenz_model');
$vertragsbestandteildbmodel = $CI->VertragsbestandteilKarenz_model;
break;
case self::VERTRAGSBESTANDTEIL_KUENDIGUNGSFRIST:
$CI->load->model('vertragsbestandteil/VertragsbestandteilKuendigungsfrist_model',
'VertragsbestandteilKuendigungsfrist_model');
$vertragsbestandteildbmodel = $CI->VertragsbestandteilKuendigungsfrist_model;
break;
case self::VERTRAGSBESTANDTEIL_STUNDEN:
$CI->load->model('vertragsbestandteil/VertragsbestandteilStunden_model',
'VertragsbestandteilStunden_model');
$vertragsbestandteildbmodel = $CI->VertragsbestandteilStunden_model;
break;
case self::VERTRAGSBESTANDTEIL_URLAUBSANSPRUCH:
$CI->load->model('vertragsbestandteil/VertragsbestandteilUrlaubsanspruch_model',
'VertragsbestandteilUrlaubsanspruch_model');
$vertragsbestandteildbmodel = $CI->VertragsbestandteilUrlaubsanspruch_model;
break;
case self::VERTRAGSBESTANDTEIL_ZEITAUFZEICHNUNG:
$CI->load->model('vertragsbestandteil/VertragsbestandteilZeitaufzeichnung_model',
'VertragsbestandteilZeitaufzeichnung_model');
$vertragsbestandteildbmodel = $CI->VertragsbestandteilZeitaufzeichnung_model;
break;
default:
throw new Exception('Unknown vertragsbestandteil_kurzbz '
. $vertragsbestandteil_kurzbz);
}
return $vertragsbestandteildbmodel;
}
}
@@ -1,134 +0,0 @@
<?php
namespace vertragsbestandteil;
use vertragsbestandteil\Vertragsbestandteil;
use vertragsbestandteil\VertragsbestandteilFactory;
class VertragsbestandteilFreitext extends Vertragsbestandteil
{
protected $freitexttyp_kurzbz;
protected $titel;
protected $anmerkung;
public function __construct()
{
parent::__construct();
$this->setVertragsbestandteiltyp_kurzbz(
VertragsbestandteilFactory::VERTRAGSBESTANDTEIL_FREITEXT);
}
public function hydrateByStdClass($data, $fromdb=false)
{
parent::hydrateByStdClass($data, $fromdb);
$this->fromdb = $fromdb;
isset($data->freitexttyp) && $this->setFreitexttypKurzbz($data->freitexttyp);
isset($data->freitexttyp_kurzbz) && $this->setFreitexttypKurzbz($data->freitexttyp_kurzbz);
isset($data->titel) && $this->setTitel($data->titel);
isset($data->freitext) && $this->setAnmerkung($data->freitext);
isset($data->anmerkung) && $this->setAnmerkung($data->anmerkung);
$this->fromdb = false;
}
public function toStdClass(): \stdClass
{
$tmp = array(
'vertragsbestandteil_id' => $this->getVertragsbestandteil_id(),
'freitexttyp_kurzbz' => $this->getFreitexttypKurzbz(),
'titel' => $this->getTitel(),
'anmerkung' => $this->getAnmerkung()
);
$tmp = array_filter($tmp, function($k) {
return in_array($k, $this->modifiedcolumns);
}, ARRAY_FILTER_USE_KEY);
return (object) $tmp;
}
public function __toString()
{
$txt = <<<EOTXT
anmerkung: {$this->getAnmerkung()}
titel: {$this->getTitel()}
freitexttyp_kurzbz: {$this->getFreitexttypKurzbz()}
EOTXT;
return parent::__toString() . $txt;
}
/**
* Get the value of anmerkung
*/
public function getAnmerkung()
{
return $this->anmerkung;
}
/**
* Set the value of anmerkung
*/
public function setAnmerkung($anmerkung): self
{
$this->markDirty('anmerkung', $this->anmerkung, $anmerkung);
$this->anmerkung = $anmerkung;
return $this;
}
/**
* Get the value of titel
*/
public function getTitel()
{
return $this->titel;
}
/**
* Set the value of titel
*/
public function setTitel($titel): self
{
$this->markDirty('titel', $this->titel, $titel);
$this->titel = $titel;
return $this;
}
/**
* Get the value of freitexttyp_kurzbz
*/
public function getFreitexttypKurzbz()
{
return $this->freitexttyp_kurzbz;
}
/**
* Set the value of freitexttyp_kurzbz
*/
public function setFreitexttypKurzbz($freitexttyp_kurzbz): self
{
$this->markDirty('freitexttyp_kurzbz', $this->freitexttyp_kurzbz, $freitexttyp_kurzbz);
$this->freitexttyp_kurzbz = $freitexttyp_kurzbz;
return $this;
}
public function validate()
{
if( empty($this->freitexttyp_kurzbz) ) {
$this->validationerrors[] = 'Bitte einen gültigen Freitexttyp auswählen.';
}
if( empty($this->titel) ) {
$this->validationerrors[] = 'Bitte einen Titel angeben.';
}
if( empty($this->anmerkung) ) {
$this->validationerrors[] = 'Bitte eine Beschreibung eingeben.';
}
return parent::validate();
}
}
@@ -1,369 +0,0 @@
<?php
namespace vertragsbestandteil;
use Exception;
use vertragsbestandteil\Vertragsbestandteil;
use vertragsbestandteil\VertragsbestandteilFactory;
/**
* Description of VertragsbestandteilFunktion
*
* @author bambi
*/
class VertragsbestandteilFunktion extends Vertragsbestandteil
{
protected $benutzerfunktion_id;
protected $benutzerfunktiondata;
protected $CI;
public function __construct()
{
parent::__construct();
$this->benutzerfunktiondata = null;
$this->setVertragsbestandteiltyp_kurzbz(
VertragsbestandteilFactory::VERTRAGSBESTANDTEIL_FUNKTION);
$this->CI = get_instance();
$this->CI->load->model('person/Benutzerfunktion_model',
'BenutzerfunktionModel');
$this->CI->load->model('vertragsbestandteil/VertragsbestandteilFunktion_model',
'VertragsbestandteilFunktionModel');
$this->CI->load->library('vertragsbestandteil/VertragsbestandteilLib',
null, 'VertragsbestandteilLib');
}
public function isDirty()
{
$isdirty = parent::isDirty();
if( !$isdirty ) {
$bf = $this->loadBenutzerfunktion($this->getBenutzerfunktion_id());
if( !$this->areVbAndBfInSync($bf) )
{
$isdirty = true;
}
}
return $isdirty;
}
public function beforePersist()
{
if( isset($this->benutzerfunktion_id) && intval($this->benutzerfunktion_id) > 0 )
{
$this->beforePersitExisting();
}
else
{
$this->beforePersitNew();
}
}
protected function loadBenutzerfunktion($bfid)
{
$bfres = $this->CI->BenutzerfunktionModel->load($bfid);
if(!hasData($bfres))
{
throw new Exception('failed to load existing Benutzerfunktion');
}
return (getData($bfres))[0];
}
protected function loadPersitedVB($vbid)
{
$vb = $this->CI->VertragsbestandteilLib->fetchVertragsbestandteil($vbid);
if( $vb === null )
{
throw new Exception('failed to load persited Vertragsbestandteil');
}
return $vb;
}
protected function areVbAndBfInSync($bf)
{
$vbvon = $this->getVon();
$vbbis = $this->getBis();
if( intval($this->getVertragsbestandteil_id()) > 0 )
{
$vb = $this->loadPersitedVB($this->getVertragsbestandteil_id());
$vbvon = $vb->getVon();
$vbbis = $vb->getBis();
}
if( ($bf->datum_von === $vbvon) && ($bf->datum_bis === $vbbis) )
{
return true;
}
return false;
}
protected function isBefore($a, $b)
{
if($a === null) {
return false;
}
elseif($b === null) {
return true;
}
else {
return $a < $b;
}
}
protected function isAfter($a, $b)
{
if($b === null) {
return false;
}
elseif($a === null) {
return true;
}
else {
return $a > $b;
}
}
protected function beforePersitExisting()
{
$bf = $this->loadBenutzerfunktion($this->getBenutzerfunktion_id());
if( $this->areVbAndBfInSync($bf) )
{
// vb or stored vb von bis is in sync so update benutzerfunktion
$this->updateBenutzerfunktion($bf, $this->getVon(), $this->getBis());
}
else
{
$daybeforevon = \DateTime::createFromFormat('Y-m-d', $this->getVon(),
new \DateTimeZone('Europe/Vienna'));
$daybeforevon->sub(new \DateInterval('P1D'));
if( $this->isBefore($bf->datum_von, $this->getVon()) &&
$this->isBefore($bf->datum_von, $this->getBis()) )
{
$data = (object) array(
'mitarbeiter_uid' => $bf->uid,
'funktion' => $bf->funktion_kurzbz,
'orget' => $bf->oe_kurzbz
);
$this->createBenutzerfunktionData($data);
$bfid = $this->insertBenutzerfunktion($this->getBenutzerfunktionData4Insert());
$this->setBenutzerfunktion_id($bfid);
}
elseif( $this->isBefore($bf->datum_von, $this->getVon()) &&
$this->isAfter($this->getBis(), $bf->datum_von) )
{
$this->updateBenutzerfunktion($bf, $bf->datum_von, $daybeforevon->format('Y-m-d'));
$data = (object) array(
'mitarbeiter_uid' => $bf->uid,
'funktion' => $bf->funktion_kurzbz,
'orget' => $bf->oe_kurzbz
);
$this->createBenutzerfunktionData($data);
$bfid = $this->insertBenutzerfunktion($this->getBenutzerfunktionData4Insert());
$this->setBenutzerfunktion_id($bfid);
}
else
{
$this->updateBenutzerfunktion($bf, $this->getVon(), $this->getBis());
}
}
}
protected function updateBenutzerfunktion($bf, $von, $bis)
{
$data = array();
if($von !== $bf->datum_von)
{
$data['datum_von'] = $von;
}
if($bis !== $bf->datum_bis)
{
$data['datum_bis'] = $bis;
}
if( count($data) === 0 )
{
return;
}
$data['updateamum'] = strftime('%Y-%m-%d %H:%M:%S');
$data['updatevon'] = getAuthUID();
$ret = $this->CI->BenutzerfunktionModel->update($bf->benutzerfunktion_id, $data);
if(isError($ret) )
{
throw new Exception('failed to update Benutzerfunktion');
}
}
protected function insertBenutzerfunktion($benutzerfunktiondata)
{
$ret = $this->CI->BenutzerfunktionModel->insert($benutzerfunktiondata);
if(isError($ret) )
{
throw new Exception('failed to create Benutzerfunktion');
}
return getData($ret);
}
protected function deleteBenutzerfunktion($benutzerfunktion_id)
{
$ret = $this->CI->BenutzerfunktionModel->delete($benutzerfunktion_id);
if(isError($ret) )
{
throw new Exception('failed to delete Benutzerfunktion');
}
}
protected function beforePersitNew() {
if( $this->benutzerfunktiondata === null)
{
return;
}
$bfid = $this->insertBenutzerfunktion($this->getBenutzerfunktionData4Insert());
$this->setBenutzerfunktion_id($bfid);
}
public function afterDelete()
{
if( !(intval($this->getBenutzerfunktion_id()) > 0) )
{
return;
}
$this->deleteBenutzerfunktion($this->getBenutzerfunktion_id());
}
public function toStdClass()
{
$tmp = array(
'vertragsbestandteil_id' => $this->getVertragsbestandteil_id(),
'benutzerfunktion_id' => $this->getBenutzerfunktion_id()
);
$tmp = array_filter($tmp, function($k) {
return in_array($k, $this->modifiedcolumns);
}, ARRAY_FILTER_USE_KEY);
return (object) $tmp;
}
public function __toString()
{
$txt = <<<EOTXT
benutzerfunktion_id: {$this->getBenutzerfunktion_id()}
EOTXT;
return parent::__toString() . $txt;
}
public function hydrateByStdClass($data, $fromdb=false)
{
parent::hydrateByStdClass($data, $fromdb);
$this->fromdb = $fromdb;
isset($data->benutzerfunktionid) && $this->setBenutzerfunktion_id($data->benutzerfunktionid);
isset($data->benutzerfunktion_id) && $this->setBenutzerfunktion_id($data->benutzerfunktion_id);
isset($data->funktion) && isset($data->orget)
&& isset($data->mitarbeiter_uid) && $this->createBenutzerfunktionData($data);
isset($data->funktion_bezeichnung) && isset($data->oe_bezeichnung)
&& $this->createBenutzerfunktionData4Display($data);
$this->fromdb = false;
}
public function getBenutzerfunktion_id()
{
return $this->benutzerfunktion_id;
}
public function setBenutzerfunktion_id($benutzerfunktion_id)
{
$this->markDirty('benutzerfunktion_id', $this->benutzerfunktion_id, $benutzerfunktion_id);
$this->benutzerfunktion_id = $benutzerfunktion_id;
return $this;
}
protected function getBenutzerfunktionData4Insert()
{
if( null === $this->benutzerfunktiondata ) {
return null;
}
$benutzerfunktiondata = (object) array(
'funktion_kurzbz' => $this->benutzerfunktiondata->funktion_kurzbz,
'oe_kurzbz' => $this->benutzerfunktiondata->oe_kurzbz,
'uid' => $this->benutzerfunktiondata->uid,
'datum_von' => $this->getVon(),
'datum_bis' => $this->getBis(),
'insertamum' => strftime('%Y-%m-%d %H:%M:%S'),
'insertvon' => getAuthUID()
);
return $benutzerfunktiondata;
}
protected function createBenutzerfunktionData($data)
{
if( empty($data->funktion) || empty($data->orget) )
{
return;
}
$this->benutzerfunktiondata = (object) array(
'funktion_kurzbz' => $data->funktion,
'oe_kurzbz' => $data->orget,
'uid' => $data->mitarbeiter_uid
);
}
protected function createBenutzerfunktionData4Display($data)
{
if( empty($data->funktion_bezeichnung) || empty($data->oe_bezeichnung) )
{
return;
}
$this->benutzerfunktiondata = (object) array(
'funktion_kurzbz' => $data->funktion_kurzbz,
'funktion_bezeichnung' => $data->funktion_bezeichnung,
'oe_kurzbz' => $data->oe_kurzbz,
'oe_bezeichnung' => $data->oe_bezeichnung,
'oe_kurzbz_sap' => $data->oe_kurzbz_sap,
'oe_typ_kurzbz' => $data->oe_typ_kurzbz,
'oe_typ_bezeichnung' => $data->oe_typ_bezeichnung,
'uid' => $data->mitarbeiter_uid
);
}
public function validate()
{
if( (intval($this->benutzerfunktion_id) < 1)
&& ($this->benutzerfunktiondata === NULL) ) {
$this->validationerrors[] = 'Eine bestehende Funktion oder eine '
. 'Funktion und eine Organisationseinheit müssen ausgewählt sein.';
}
// TODO check if Benutzerfunktion is assigned to another vb
if( intval($this->benutzerfunktion_id) > 0 )
{
if ( $this->CI->VertragsbestandteilFunktionModel
->isBenutzerfunktionAlreadyAttachedToAnotherVB(
$this->benutzerfunktion_id,
$this->getVertragsbestandteil_id()) )
{
$this->validationerrors[] = 'Die Benutzerfunktion ist bereits '
. 'mit einem anderen Vertragsbestandteil verknüpft und kann '
. 'nicht mehrfach verknüft werden.';
}
}
return parent::validate();
}
}
@@ -1,141 +0,0 @@
<?php
namespace vertragsbestandteil;
use vertragsbestandteil\Vertragsbestandteil;
use vertragsbestandteil\VertragsbestandteilFactory;
class VertragsbestandteilKarenz extends Vertragsbestandteil
{
protected $karenztyp_kurzbz;
protected $tatsaechlicher_geburtstermin;
protected $geplanter_geburtstermin;
public function __construct()
{
parent::__construct();
$this->setVertragsbestandteiltyp_kurzbz(
VertragsbestandteilFactory::VERTRAGSBESTANDTEIL_KARENZ);
}
public function hydrateByStdClass($data, $fromdb=false)
{
parent::hydrateByStdClass($data, $fromdb);
$this->fromdb = $fromdb;
isset($data->karenztyp_kurzbz) && $this->setKarenztypKurzbz($data->karenztyp_kurzbz);
isset($data->geplanter_geburtstermin) && $this->setGeplanterGeburtstermin($data->geplanter_geburtstermin);
isset($data->tatsaechlicher_geburtstermin) && $this->setTatsaechlicherGeburtstermin($data->tatsaechlicher_geburtstermin);
$this->fromdb = false;
}
/**
* Get the value of karenztyp_kurzbz
*/
public function getKarenztypKurzbz()
{
return $this->karenztyp_kurzbz;
}
/**
* Set the value of karenztyp_kurzbz
*/
public function setKarenztypKurzbz($karenztyp_kurzbz): self
{
$this->markDirty('karenztyp_kurzbz', $this->karenztyp_kurzbz, $karenztyp_kurzbz);
$this->karenztyp_kurzbz = $karenztyp_kurzbz;
return $this;
}
/**
* Get the value of tatsaechlicher_geburtstermin
*/
public function getTatsaechlicherGeburtstermin()
{
return $this->tatsaechlicher_geburtstermin;
}
/**
* Set the value of tatsaechlicher_geburtstermin
*/
public function setTatsaechlicherGeburtstermin($tatsaechlicher_geburtstermin): self
{
$this->markDirty('tatsaechlicher_geburtstermin', $this->tatsaechlicher_geburtstermin, $tatsaechlicher_geburtstermin);
$this->tatsaechlicher_geburtstermin = $tatsaechlicher_geburtstermin;
return $this;
}
/**
* Get the value of geplanter_geburtstermin
*/
public function getGeplanterGeburtstermin()
{
return $this->geplanter_geburtstermin;
}
/**
* Set the value of geplanter_geburtstermin
*/
public function setGeplanterGeburtstermin($geplanter_geburtstermin): self
{
$this->markDirty('geplanter_geburtstermin', $this->geplanter_geburtstermin, $geplanter_geburtstermin);
$this->geplanter_geburtstermin = $geplanter_geburtstermin;
return $this;
}
public function toStdClass(): \stdClass
{
$tmp = array(
'vertragsbestandteil_id' => $this->getVertragsbestandteil_id(),
'karenztyp_kurzbz' => $this->getKarenztypKurzbz(),
'tatsaechlicher_geburtstermin' => $this->getTatsaechlicherGeburtstermin(),
'geplanter_geburtstermin' => $this->getGeplanterGeburtstermin()
);
$tmp = array_filter($tmp, function($k) {
return in_array($k, $this->modifiedcolumns);
}, ARRAY_FILTER_USE_KEY);
return (object) $tmp;
}
public function __toString()
{
$txt = <<<EOTXT
karenztyp_kurzbz: {$this->getKarenztypKurzbz()}
tatsaechlicher_geburtstermin: {$this->getTatsaechlicherGeburtstermin()}
geplanter_geburtstermin: {$this->getGeplanterGeburtstermin()}
EOTXT;
return parent::__toString() . $txt;
}
public function validate()
{
if( empty($this->karenztyp_kurzbz) ) {
$this->validationerrors[] = 'Ein Karenztyp muss ausgewählt sein.';
}
if( $this->karenztyp_kurzbz === 'elternkarenz' ) {
$geplant = \DateTimeImmutable::createFromFormat('Y-m-d', $this->geplanter_geburtstermin);
$tatsaechlich = \DateTimeImmutable::createFromFormat('Y-m-d', $this->tatsaechlicher_geburtstermin);
if( false === $geplant ) {
$this->validationerrors[] = 'Bei Elternkarenz muss der geplanter Geburtstermin ein gültiges Datum sein.';
}
if( !empty($this->tatsaechlicher_geburtstermin) && $tatsaechlich === false ) {
$this->validationerrors[] = 'Bei Elternkarenz muss der tatsaechliche Geburtstermin leer oder ein gültiges Datum sein.';
}
}
$bis = \DateTimeImmutable::createFromFormat('Y-m-d', $this->bis);
if( false === $bis ) {
$this->validationerrors[] = 'Bei einer Karenz muss ein gültiges Ende-Datum angegeben werden.';
}
return parent::validate();
}
}
@@ -1,117 +0,0 @@
<?php
namespace vertragsbestandteil;
use vertragsbestandteil\Vertragsbestandteil;
use vertragsbestandteil\VertragsbestandteilFactory;
class VertragsbestandteilKuendigungsfrist extends Vertragsbestandteil
{
protected $arbeitgeber_frist;
protected $arbeitnehmer_frist;
public function __construct()
{
parent::__construct();
$this->setVertragsbestandteiltyp_kurzbz(
VertragsbestandteilFactory::VERTRAGSBESTANDTEIL_KUENDIGUNGSFRIST);
}
public function hydrateByStdClass($data, $fromdb=false)
{
parent::hydrateByStdClass($data, $fromdb);
$this->fromdb = $fromdb;
isset($data->arbeitgeber_frist) && $this->setArbeitgeberFrist($data->arbeitgeber_frist);
isset($data->arbeitnehmer_frist) && $this->setArbeitnehmerFrist($data->arbeitnehmer_frist);
$this->fromdb = false;
}
/**
* Get the value of arbeitgeber_frist
*/
public function getArbeitgeberFrist()
{
return $this->arbeitgeber_frist;
}
/**
* Set the value of arbeitgeber_frist
*/
public function setArbeitgeberFrist($arbeitgeber_frist): self
{
$this->markDirty('arbeitgeber_frist', $this->arbeitgeber_frist, $arbeitgeber_frist);
$this->arbeitgeber_frist = $arbeitgeber_frist;
return $this;
}
/**
* Get the value of arbeitnehmer_frist
*/
public function getArbeitnehmerFrist()
{
return $this->arbeitnehmer_frist;
}
/**
* Set the value of arbeitnehmer_frist
*/
public function setArbeitnehmerFrist($arbeitnehmer_frist): self
{
$this->markDirty('arbeitnehmer_frist', $this->arbeitnehmer_frist, $arbeitnehmer_frist);
$this->arbeitnehmer_frist = $arbeitnehmer_frist;
return $this;
}
public function toStdClass(): \stdClass
{
$tmp = array(
'vertragsbestandteil_id' => $this->getVertragsbestandteil_id(),
'arbeitgeber_frist' => $this->getArbeitgeberFrist(),
'arbeitnehmer_frist' => $this->getArbeitnehmerFrist()
);
$tmp = array_filter($tmp, function($k) {
return in_array($k, $this->modifiedcolumns);
}, ARRAY_FILTER_USE_KEY);
return (object) $tmp;
}
public function __toString()
{
$txt = <<<EOTXT
arbeitgeber_frist: {$this->getArbeitgeberFrist()}
arbeitnehmer_frist: {$this->getArbeitnehmerFrist()}
EOTXT;
return parent::__toString() . $txt;
}
public function validate()
{
if( !(filter_var($this->arbeitgeber_frist, FILTER_VALIDATE_INT,
array(
'options' => array(
'min_range' => 0,
'max_range' => 52
)
)
)) ) {
$this->validationerrors[] = 'Arbeitgeberfrist muss eine Wochenanzahl im Bereich 1 bis 52 sein.';
}
if( !(filter_var($this->arbeitnehmer_frist, FILTER_VALIDATE_INT,
array(
'options' => array(
'min_range' => 1,
'max_range' => 52
)
)
)) ) {
$this->validationerrors[] = 'Arbeitnehmerfrist muss eine Wochenanzahl im Bereich 1 bis 52 sein.';
}
return parent::validate();
}
}
@@ -1,504 +0,0 @@
<?php
require_once __DIR__ . '/IValidation.php';
require_once __DIR__ . '/AbstractBestandteil.php';
require_once __DIR__ . '/Dienstverhaeltnis.php';
require_once __DIR__ . '/Vertragsbestandteil.php';
require_once __DIR__ . '/VertragsbestandteilStunden.php';
require_once __DIR__ . '/VertragsbestandteilFunktion.php';
require_once __DIR__ . '/VertragsbestandteilZeitaufzeichnung.php';
require_once __DIR__ . '/VertragsbestandteilKuendigungsfrist.php';
require_once __DIR__ . '/VertragsbestandteilUrlaubsanspruch.php';
require_once __DIR__ . '/VertragsbestandteilFreitext.php';
require_once __DIR__ . '/VertragsbestandteilKarenz.php';
require_once __DIR__ . '/VertragsbestandteilFactory.php';
require_once __DIR__ . '/OverlapChecker.php';
use vertragsbestandteil\Dienstverhaeltnis;
use vertragsbestandteil\Vertragsbestandteil;
use vertragsbestandteil\VertragsbestandteilFactory;
/**
* Description of VertragsbestandteilLib
*
* @author bambi
*/
class VertragsbestandteilLib
{
const INCLUDE_FUTURE = true;
const DO_NOT_INCLUDE_FUTURE = false;
protected $CI;
/** @var Dienstverhaeltnis_model */
protected $DienstverhaeltnisModel;
/** @var Vertragsbestandteil_model */
protected $VertragsbestandteilModel;
/** @var Benutzer_model */
protected $BenutzerModel;
/**
* @var GehaltsbestandteilLib
*/
protected $GehaltsbestandteilLib;
protected $loggedInUser;
public function __construct()
{
$this->loggedInUser = getAuthUID();
$this->CI = get_instance();
$this->CI->load->model('vertragsbestandteil/Dienstverhaeltnis_model',
'DienstverhaeltnisModel');
$this->DienstverhaeltnisModel = $this->CI->DienstverhaeltnisModel;
$this->CI->load->model('vertragsbestandteil/Vertragsbestandteil_model',
'VertragsbestandteilModel');
$this->VertragsbestandteilModel = $this->CI->VertragsbestandteilModel;
$this->CI->load->model('person/benutzer_model',
'BenutzerModel');
$this->BenutzerModel = $this->CI->BenutzerModel;
$this->CI->load->library('vertragsbestandteil/GehaltsbestandteilLib',
null, 'GehaltsbestandteilLib');
$this->GehaltsbestandteilLib = $this->CI->GehaltsbestandteilLib;
}
public function handleGUIData($guidata, $employeeUID, $userUID)
{
$guiHandler = new GUIHandler($employeeUID, $userUID);
$ret = false;
try {
$ret = $guiHandler->handle($guidata, $employeeUID, $userUID);
} catch (Exception $ex)
{
log_message('debug', "Error handling json data from GUI. " . $ex->getMessage());
}
return $ret;
}
public function fetchDienstverhaeltnisse($unternehmen, $stichtag=null, $mitarbeiteruid=null) {
$dvs = $this->DienstverhaeltnisModel->fetchDienstverhaeltnisse($unternehmen, $stichtag, $mitarbeiteruid);
return $dvs;
}
public function fetchDienstverhaeltnis($dienstverhaeltnis_id)
{
$result = $this->DienstverhaeltnisModel->load($dienstverhaeltnis_id);
$dv = null;
if(null !== ($row = getData($result)))
{
$dv = new Dienstverhaeltnis();
$dv->hydrateByStdClass($row[0], true);
}
return $dv;
}
public function fetchVertragsbestandteile($dienstverhaeltnis_id, $stichtag=null, $includefuture=false)
{
$vbs = $this->VertragsbestandteilModel->getVertragsbestandteile($dienstverhaeltnis_id, $stichtag, $includefuture);
$gbs = $this->GehaltsbestandteilLib->fetchGehaltsbestandteile($dienstverhaeltnis_id, $stichtag, $includefuture);
$gbsByVBid = array();
foreach( $gbs as $gb )
{
if( intval($gb->getVertragsbestandteil_id()) > 0 )
{
if( !isset($gbsByVBid[$gb->getVertragsbestandteil_id()])
|| !is_array($gbsByVBid[$gb->getVertragsbestandteil_id()]) ) {
$gbsByVBid[$gb->getVertragsbestandteil_id()] = array();
}
$gbsByVBid[$gb->getVertragsbestandteil_id()][] = $gb;
}
}
foreach ($vbs as $vb)
{
if( isset($gbsByVBid[$vb->getVertragsbestandteil_id()]) )
{
$vb->setGehaltsbestandteile($gbsByVBid[$vb->getVertragsbestandteil_id()]);
}
}
return $vbs;
}
public function fetchVertragsbestandteil($vertragsbestandteil_id)
{
return $this->VertragsbestandteilModel->getVertragsbestandteil($vertragsbestandteil_id);
}
public function storeDienstverhaeltnis(Dienstverhaeltnis $dv)
{
if( intval($dv->getDienstverhaeltnis_id()) > 0 )
{
$this->updateDienstverhaeltnis($dv);
}
else
{
$this->insertDienstverhaeltnis($dv);
}
}
public function storeVertragsbestandteil(Vertragsbestandteil $vertragsbestandteil)
{
$this->CI->db->trans_begin();
try
{
$this->setUIDtoPGSQL();
if( intval($vertragsbestandteil->getVertragsbestandteil_id()) > 0 )
{
$this->updateVertragsbestandteil($vertragsbestandteil);
}
else
{
$this->insertVertragsbestandteil($vertragsbestandteil);
}
if( $this->CI->db->trans_status() === false )
{
log_message('debug', "Transaction failed");
throw new Exception("Transaction failed");
}
$this->CI->db->trans_commit();
}
catch (Exception $ex)
{
log_message('debug', "Transaction rolled back. " . $ex->getMessage());
$this->CI->db->trans_rollback();
throw new Exception('Storing Vertragsbestandteil failed.');
}
}
public function deleteDienstverhaeltnis(Dienstverhaeltnis $dv)
{
$this->CI->db->trans_begin();
try
{
$this->setUIDtoPGSQL();
if( intval($dv->getDienstverhaeltnis_id()) > 0 )
{
$vbs = $this->fetchVertragsbestandteile($dv->getDienstverhaeltnis_id());
foreach ($vbs as $vb)
{
$this->deleteVertragsbestandteil($vb);
}
$ret = $this->DienstverhaeltnisModel->delete($dv->getDienstverhaeltnis_id());
if(isError($ret) )
{
log_message('debug', "Delete DV failed");
throw new Exception('error deleting dienstverhaeltnis '
. $dv->getDienstverhaeltnis_id());
}
if( $this->CI->db->trans_status() === false )
{
log_message('debug', "Transaction failed");
throw new Exception("Transaction failed");
}
$this->CI->db->trans_commit();
}
}
catch (Exception $ex)
{
log_message('debug', "Transaction rolled back. " . $ex->getMessage());
$this->CI->db->trans_rollback();
return $ex->getMessage();
}
return true;
}
public function deleteVertragsbestandteil(Vertragsbestandteil $vertragsbestandteil)
{
$this->CI->db->trans_begin();
try
{
$this->setUIDtoPGSQL();
if( intval($vertragsbestandteil->getVertragsbestandteil_id()) > 0 )
{
$this->deleteVertragsbestandteilHelper($vertragsbestandteil);
}
if( $this->CI->db->trans_status() === false )
{
log_message('debug', "Transaction failed");
throw new Exception("Transaction failed");
}
$this->CI->db->trans_commit();
}
catch (Exception $ex)
{
log_message('debug', "Transaction rolled back. " . $ex->getMessage());
$this->CI->db->trans_rollback();
throw new Exception('Delete Vertragsbestandteil failed.');
}
}
protected function insertDienstverhaeltnis(Dienstverhaeltnis $dv)
{
$dv->setInsertvon($this->loggedInUser)
->setInsertamum(strftime('%Y-%m-%d %H:%M:%S'));
$ret = $this->DienstverhaeltnisModel->insert($dv->toStdClass());
if( hasData($ret) )
{
$dv->setDienstverhaeltnis_id(getData($ret));
}
else
{
throw new Exception('error inserting dienstverhaeltnis');
}
}
protected function insertVertragsbestandteil(Vertragsbestandteil $vertragsbestandteil)
{
$vertragsbestandteil->setInsertvon($this->loggedInUser)
->setInsertamum(strftime('%Y-%m-%d %H:%M:%S'));
$vertragsbestandteil->beforePersist();
$ret = $this->VertragsbestandteilModel->insert($vertragsbestandteil->baseToStdClass());
if( hasData($ret) )
{
$vertragsbestandteil->setVertragsbestandteil_id(getData($ret));
}
else
{
throw new Exception('error inserting vertragsbestandteil');
}
$specialisedModel = VertragsbestandteilFactory::getVertragsbestandteilDBModel(
$vertragsbestandteil->getVertragsbestandteiltyp_kurzbz());
$retspecial = $specialisedModel->insert($vertragsbestandteil->toStdClass());
if(isError($retspecial) )
{
throw new Exception('error updating vertragsbestandteil '
. $vertragsbestandteil->getVertragsbestandteiltyp_kurzbz());
}
try
{
$gehaltsbestandteile = $vertragsbestandteil->getGehaltsbestandteile();
$this->GehaltsbestandteilLib->storeGehaltsbestandteile($gehaltsbestandteile);
}
catch(Exception $ex)
{
throw new Exception('VertragsbestandteilLib insertVertragsbestandteil '
. 'failed to store Gehaltsbestandteile. ' . $ex->getMessage());
}
}
protected function updateDienstverhaeltnis(Dienstverhaeltnis $dv)
{
if(!$dv->isDirty()) {
return;
}
$dv->setUpdatevon($this->loggedInUser)
->setUpdateamum(strftime('%Y-%m-%d %H:%M:%S'));
$ret = $this->DienstverhaeltnisModel->update($dv->getDienstverhaeltnis_id(),
$dv->toStdClass());
if(isError($ret) )
{
throw new Exception('error updating dienstverhaeltnis');
}
}
private function deleteVertragsbestandteilHelper(Vertragsbestandteil $vertragsbestandteil)
{
$specialisedModel = VertragsbestandteilFactory::getVertragsbestandteilDBModel(
$vertragsbestandteil->getVertragsbestandteiltyp_kurzbz());
$retspecial = $specialisedModel->delete($vertragsbestandteil->getVertragsbestandteil_id());
if(isError($retspecial) )
{
throw new Exception('error deleting vertragsbestandteil '
. $vertragsbestandteil->getVertragsbestandteiltyp_kurzbz());
}
try
{
$gehaltsbestandteile = $vertragsbestandteil->getGehaltsbestandteile();
$this->GehaltsbestandteilLib->deleteGehaltsbestandteile($gehaltsbestandteile);
}
catch(Exception $ex)
{
throw new Exception('VertragsbestandteilLib deleteVertragsbestandteil '
. 'failed to delete Gehaltsbestandteile. ' . $ex->getMessage());
}
$ret = $this->VertragsbestandteilModel->delete($vertragsbestandteil->getVertragsbestandteil_id());
if(isError($ret) )
{
throw new Exception('error deleting vertragsbestandteil');
}
$vertragsbestandteil->afterDelete();
}
protected function updateVertragsbestandteil(Vertragsbestandteil $vertragsbestandteil)
{
if($vertragsbestandteil->isDirty()) {
$vertragsbestandteil->setUpdatevon($this->loggedInUser)
->setUpdateamum(strftime('%Y-%m-%d %H:%M:%S'));
$vertragsbestandteil->beforePersist();
$basedata = $vertragsbestandteil->baseToStdClass();
if( count((array) $basedata) > 0 )
{
$ret = $this->VertragsbestandteilModel->update(
$vertragsbestandteil->getVertragsbestandteil_id(),
$basedata);
if(isError($ret) )
{
throw new Exception('error updating vertragsbestandteil');
}
}
$specialisedData = $vertragsbestandteil->toStdClass();
if( count((array) $specialisedData) > 0 )
{
$specialisedModel = VertragsbestandteilFactory::getVertragsbestandteilDBModel(
$vertragsbestandteil->getVertragsbestandteiltyp_kurzbz());
$retspecial = $specialisedModel->update(
$vertragsbestandteil->getVertragsbestandteil_id(),
$specialisedData);
if(isError($retspecial) )
{
throw new Exception('error updating vertragsbestandteil '
. $vertragsbestandteil->getVertragsbestandteiltyp_kurzbz());
}
}
}
try
{
$gehaltsbestandteile = $vertragsbestandteil->getGehaltsbestandteile();
$this->GehaltsbestandteilLib->storeGehaltsbestandteile($gehaltsbestandteile);
}
catch(Exception $ex)
{
throw new Exception('VertragsbestandteilLib updateVertragsbestandteil '
. 'failed to store Gehaltsbestandteile. ' . $ex->getMessage());
}
}
public function isOverlappingExistingDV(Dienstverhaeltnis $dv)
{
return $this->DienstverhaeltnisModel->isOverlappingExistingDV(
$dv->getMitarbeiter_uid(),
$dv->getOe_kurzbz(),
$dv->getVon(),
$dv->getBis(),
$dv->getDienstverhaeltnis_id()
);
}
protected function hasOtherActiveDV(Dienstverhaeltnis $dv, $duedate)
{
$hasotheractivedv = false;
$result = $this->DienstverhaeltnisModel->getDVByPersonUID($dv->getMitarbeiter_uid(), null, $duedate);
$dvs = getData($result);
foreach ($dvs as $tmpdv)
{
if(intval($tmpdv->dienstverhaeltnis_id) !== intval($dv->getDienstverhaeltnis_id()))
{
$hasotheractivedv = true;
break;
}
}
return $hasotheractivedv;
}
/**
* like endDienstverhaeltnis, but also sets aktiv flag to false
*/
public function deactivateDienstverhaeltnis(Dienstverhaeltnis $dv, $enddate, $deactivate)
{
$result = $this->endDienstverhaeltnis($dv, $enddate);
if ( $result === true)
{
if (!$deactivate) return $result;
if(!$this->hasOtherActiveDV($dv, $enddate))
{
$result = $this->BenutzerModel->update(
array('uid' => $dv->getMitarbeiter_uid()),
array(
'aktiv' => false,
'updateaktivam' => date('Y-m-d'),
'updateaktivvon' => $this->loggedInUser
)
);
}
}
return $result;
}
public function endDienstverhaeltnis(Dienstverhaeltnis $dv, $enddate)
{
if( $dv->getBis() !== null && $dv->getBis() < $enddate )
{
return 'Dienstverhältnis ist bereits beendet.';
}
$this->CI->db->trans_begin();
try
{
$this->setUIDtoPGSQL();
if( intval($dv->getDienstverhaeltnis_id()) > 0 )
{
$gbs = $this->GehaltsbestandteilLib->fetchGehaltsbestandteile($dv->getDienstverhaeltnis_id());
foreach ($gbs as $gb)
{
$this->GehaltsbestandteilLib->endGehaltsbestandteil($gb, $enddate);
}
$vbs = $this->fetchVertragsbestandteile($dv->getDienstverhaeltnis_id());
foreach ($vbs as $vb)
{
$this->endVertragsbestandteil($vb, $enddate);
}
$dv->setBis($enddate);
$this->updateDienstverhaeltnis($dv);
if( $this->CI->db->trans_status() === false )
{
log_message('debug', "Transaction failed");
throw new Exception("Transaction failed");
}
$this->CI->db->trans_commit();
}
}
catch (Exception $ex)
{
log_message('debug', "end DV failed " . $dv->getDienstverhaeltnis_id());
log_message('debug', "Transaction rolled back. " . $ex->getMessage());
$this->CI->db->trans_rollback();
return $ex->getMessage();
}
return true;
}
public function endVertragsbestandteil(Vertragsbestandteil $vertragsbestandteil, $enddate)
{
if( $vertragsbestandteil->getBis() !== null && $vertragsbestandteil->getBis() < $enddate )
{
return;
}
$vertragsbestandteil->setBis($enddate);
$this->updateVertragsbestandteil($vertragsbestandteil);
}
protected function setUIDtoPGSQL() {
$ret = $this->VertragsbestandteilModel
->execReadOnlyQuery('SET LOCAL pv21.uid TO \''
. $this->loggedInUser . '\'');
if(isError($ret))
{
throw new Exception('error setting uid to pgsql');
}
}
}
@@ -1,110 +0,0 @@
<?php
namespace vertragsbestandteil;
use vertragsbestandteil\Vertragsbestandteil;
use vertragsbestandteil\VertragsbestandteilFactory;
/**
* Description of VertragsbestandteilStunden
*
* @author bambi
*/
class VertragsbestandteilStunden extends Vertragsbestandteil
{
protected $wochenstunden;
protected $teilzeittyp_kurzbz;
public function __construct()
{
parent::__construct();
$this->setVertragsbestandteiltyp_kurzbz(
VertragsbestandteilFactory::VERTRAGSBESTANDTEIL_STUNDEN);
}
public function hydrateByStdClass($data, $fromdb=false)
{
parent::hydrateByStdClass($data, $fromdb);
$this->fromdb = $fromdb;
isset($data->wochenstunden) && $this->setWochenstunden($data->wochenstunden);
isset($data->teilzeittyp_kurzbz) && $this->setTeilzeittyp_kurzbz($data->teilzeittyp_kurzbz);
$this->fromdb = false;
}
public function getWochenstunden()
{
return $this->wochenstunden;
}
public function getTeilzeittyp_kurzbz()
{
return $this->teilzeittyp_kurzbz;
}
public function setWochenstunden($wochenstunden)
{
$this->markDirty('wochenstunden', $this->wochenstunden, $wochenstunden);
$this->wochenstunden = $wochenstunden;
return $this;
}
public function setTeilzeittyp_kurzbz($teilzeittyp_kurzbz)
{
$teilzeittyp_kurzbz = ($teilzeittyp_kurzbz !== '')
? $teilzeittyp_kurzbz : null;
$this->markDirty('teilzeittyp_kurzbz', $this->teilzeittyp_kurzbz, $teilzeittyp_kurzbz);
$this->teilzeittyp_kurzbz = $teilzeittyp_kurzbz;
return $this;
}
public function toStdClass(): \stdClass
{
$tmp = array(
'vertragsbestandteil_id' => $this->getVertragsbestandteil_id(),
'wochenstunden' => $this->getWochenstunden(),
'teilzeittyp_kurzbz' => $this->getTeilzeittyp_kurzbz()
);
$tmp = array_filter($tmp, function($k) {
return in_array($k, $this->modifiedcolumns);
}, ARRAY_FILTER_USE_KEY);
return (object) $tmp;
}
public function __toString()
{
$txt = <<<EOTXT
wochenstunden: {$this->getWochenstunden()}
teilzeittyp_kurzbz: {$this->getTeilzeittyp_kurzbz()}
EOTXT;
return parent::__toString() . $txt;
}
public function validate()
{
if( false === filter_var($this->wochenstunden, FILTER_VALIDATE_FLOAT,
array(
'options' => array(
'min_range' => 0,
'max_range' => 100
)
)
) ) {
$this->validationerrors[] = 'Stunden muss eine Kommazahl im Bereich 0 bis 100 sein.';
}
else
{
if( floatval($this->wochenstunden) < floatval('0.01') &&
$this->teilzeittyp_kurzbz !== 'altersteilzeit' )
{
$this->validationerrors[] = '0 Wochenstunden ist nur in Kombination mit Altersteilzeit zulässig.';
}
}
return parent::validate();
}
}
@@ -1,83 +0,0 @@
<?php
namespace vertragsbestandteil;
use vertragsbestandteil\Vertragsbestandteil;
use vertragsbestandteil\VertragsbestandteilFactory;
class VertragsbestandteilUrlaubsanspruch extends Vertragsbestandteil
{
protected $tage;
public function __construct()
{
parent::__construct();
$this->setVertragsbestandteiltyp_kurzbz(
VertragsbestandteilFactory::VERTRAGSBESTANDTEIL_URLAUBSANSPRUCH);
}
public function hydrateByStdClass($data, $fromdb=false)
{
parent::hydrateByStdClass($data, $fromdb);
$this->fromdb = $fromdb;
isset($data->tage) && $this->setTage($data->tage);
$this->fromdb = false;
}
/**
* Get the value of tage
*/
public function getTage()
{
return $this->tage;
}
/**
* Set the value of tage
*/
public function setTage($tage): self
{
$this->markDirty('tage', $this->tage, $tage);
$this->tage = $tage;
return $this;
}
public function toStdClass(): \stdClass
{
$tmp = array(
'vertragsbestandteil_id' => $this->getVertragsbestandteil_id(),
'tage' => $this->getTage(),
);
$tmp = array_filter($tmp, function($k) {
return in_array($k, $this->modifiedcolumns);
}, ARRAY_FILTER_USE_KEY);
return (object) $tmp;
}
public function __toString()
{
$txt = <<<EOTXT
tage: {$this->getTage()}
EOTXT;
return parent::__toString() . $txt;
}
public function validate()
{
if( !(filter_var($this->tage, FILTER_VALIDATE_INT,
array(
'options' => array(
'min_range' => 1,
'max_range' => 50
)
)
)) ) {
$this->validationerrors[] = 'Urlaubsanspruch muss eine Tagesanzahl im Bereich 1 bis 50 sein.';
}
return parent::validate();
}
}
@@ -1,118 +0,0 @@
<?php
namespace vertragsbestandteil;
use vertragsbestandteil\Vertragsbestandteil;
use vertragsbestandteil\VertragsbestandteilFactory;
class VertragsbestandteilZeitaufzeichnung extends Vertragsbestandteil
{
protected $zeitaufzeichnung;
protected $azgrelevant;
protected $homeoffice;
public function __construct()
{
parent::__construct();
$this->setVertragsbestandteiltyp_kurzbz(
VertragsbestandteilFactory::VERTRAGSBESTANDTEIL_ZEITAUFZEICHNUNG);
}
public function hydrateByStdClass($data, $fromdb=false)
{
parent::hydrateByStdClass($data, $fromdb);
$this->fromdb = $fromdb;
isset($data->zeitaufzeichnung) && $this->setZeitaufzeichnung($data->zeitaufzeichnung);
isset($data->azgrelevant) && $this->setAzgrelevant($data->azgrelevant);
isset($data->homeoffice) && $this->setHomeoffice($data->homeoffice);
$this->fromdb = false;
}
/**
* Get the value of zeitaufzeichnung
*/
public function getZeitaufzeichnung()
{
return $this->zeitaufzeichnung;
}
/**
* Set the value of zeitaufzeichnung
*/
public function setZeitaufzeichnung($zeitaufzeichnung): self
{
$this->markDirty('zeitaufzeichnung', $this->zeitaufzeichnung, $zeitaufzeichnung);
$this->zeitaufzeichnung = $zeitaufzeichnung;
return $this;
}
/**
* Get the value of azgrelevant
*/
public function getAzgrelevant()
{
return $this->azgrelevant;
}
/**
* Set the value of azgrelevant
*/
public function setAzgrelevant($azgrelevant): self
{
$this->markDirty('azgrelevant', $this->azgrelevant, $azgrelevant);
$this->azgrelevant = $azgrelevant;
return $this;
}
/**
* Get the value of homeoffice
*/
public function getHomeoffice()
{
return $this->homeoffice;
}
/**
* Set the value of homeoffice
*/
public function setHomeoffice($homeoffice): self
{
$this->markDirty('homeoffice', $this->homeoffice, $homeoffice);
$this->homeoffice = $homeoffice;
return $this;
}
public function toStdClass(): \stdClass
{
$tmp = array(
'vertragsbestandteil_id' => $this->getVertragsbestandteil_id(),
'zeitaufzeichnung' => $this->getZeitaufzeichnung(),
'azgrelevant' => $this->getAzgrelevant(),
'homeoffice' => $this->getHomeoffice()
);
$tmp = array_filter($tmp, function($k) {
return in_array($k, $this->modifiedcolumns);
}, ARRAY_FILTER_USE_KEY);
return (object) $tmp;
}
public function __toString()
{
$txt = <<<EOTXT
zeitaufzeichnung: {$this->getZeitaufzeichnung()}
azgrelevant: {$this->getAzgrelevant()}
homeoffice: {$this->getHomeoffice()}
EOTXT;
return parent::__toString() . $txt;
}
public function validate()
{
return parent::validate();
}
}
@@ -1,30 +0,0 @@
<?php
class Abschluss_model extends DB_Model
{
/**
* Constructor
*/
public function __construct()
{
parent::__construct();
$this->dbTable = 'bis.tbl_abschluss';
$this->pk = 'ausbildung_code';
}
public function getActiveAbschluesse($languageIndex)
{
return $this->execQuery(
'
SELECT
ausbildung_code, bezeichnung[?], in_oesterreich
FROM
bis.tbl_abschluss
WHERE
aktiv
ORDER BY
CASE WHEN in_oesterreich THEN 0 ELSE 1 END, ausbildung_code',
array($languageIndex)
);
}
}
@@ -1,35 +0,0 @@
<?php
class Bismeldestichtag_model extends DB_Model
{
/**
* Constructor
*/
public function __construct()
{
parent::__construct();
$this->dbTable = 'bis.tbl_bismeldestichtag';
$this->pk = 'meldestichtag_id';
}
/**
* Gets last Bismeldestichtag for a Studiensemester.
* @param $studiensemester_kurzbz
* @return object success or error
*/
public function getByStudiensemester($studiensemester_kurzbz)
{
$query = '
SELECT
meldestichtag
FROM
bis.tbl_bismeldestichtag
JOIN public.tbl_studiensemester USING (studiensemester_kurzbz)
WHERE
studiensemester_kurzbz = ?
ORDER BY meldestichtag DESC
LIMIT 1';
return $this->execQuery($query, array($studiensemester_kurzbz));
}
}
@@ -1,14 +0,0 @@
<?php
class Uhstat1daten_model extends DB_Model
{
/**
* Constructor
*/
public function __construct()
{
parent::__construct();
$this->dbTable = 'bis.tbl_uhstat1daten';
$this->pk = 'uhstat1daten_id';
}
}
+3 -40
View File
@@ -100,8 +100,8 @@ class Konto_model extends DB_Model
public function checkStudienbeitrag($uid, $stsem, $buchungstypen)
{
$query = 'SELECT tbl_konto.buchungsnr,
tbl_konto.buchungsdatum
$query = 'SELECT tbl_konto.buchungsnr,
tbl_konto.buchungsdatum
FROM public.tbl_konto,
public.tbl_benutzer,
public.tbl_student
@@ -117,47 +117,10 @@ class Konto_model extends DB_Model
FROM public.tbl_konto skonto
WHERE skonto.buchungsnr = tbl_konto.buchungsnr_verweis
OR skonto.buchungsnr_verweis = tbl_konto.buchungsnr_verweis
)
)
ORDER BY buchungsnr DESC LIMIT 1
';
return $this->execQuery($query);
}
/**
* check if student has paid studienbeitrag for certain semester
*
* @param $person_id person_id
* @param $stsem stsem
*
* @return boolean
*/
public function checkStudienbeitragFromPerson($person_id, $stsem)
{
$this->addOrder('buchungsnr');
$this->addLimit(1);
$result = $this->loadWhere([
'person_id'=>$person_id,
'studiensemester_kurzbz' => $stsem,
'buchungstyp_kurzbz' => 'Studiengebuehr'
]);
if (!getData($result))
return false;
$data = getData($result)[0];
$this->resetQuery();
$this->addSelect('sum(betrag) as differenz');
$this->db->or_where('buchungsnr', $data->buchungsnr);
$this->db->or_where('buchungsnr_verweis', $data->buchungsnr);
$result = $this->load();
if (!getData($result))
return false;
$data = getData($result)[0];
return $data->differenz >= 0;
}
}
@@ -2,10 +2,6 @@
class Prestudentstatus_model extends DB_Model
{
const STATUS_ABBRECHER = 'Abbrecher';
const STATUS_UNTERBRECHER = 'Unterbrecher';
/**
* Constructor
*/
@@ -230,113 +226,4 @@ class Prestudentstatus_model extends DB_Model
return $this->execQuery($query, $parametersArray);
}
/**
* get Email of relevant Studiengang of prestudent
*/
public function getLastStatusWithStgEmail($prestudent_id, $studiensemester_kurzbz = '', $status_kurzbz = '')
{
$this->addSelect('tbl_prestudentstatus.*,
tbl_studienplan.bezeichnung AS studienplan_bezeichnung,
tbl_orgform.orgform_kurzbz AS orgform,
tbl_studienplan.sprache,
tbl_orgform.bezeichnung_mehrsprachig AS bezeichnung_orgform,
tbl_status.bezeichnung_mehrsprachig,
tbl_status_grund.bezeichnung_mehrsprachig AS bezeichnung_statusgrund,
tbl_studiengang.bezeichnung AS stg_bezeichnung,
tbl_studiengang.email');
$this->addJoin('lehre.tbl_studienplan', 'studienplan_id', 'LEFT');
$this->addJoin('lehre.tbl_studienordnung', 'studienordnung_id', 'LEFT');
$this->addJoin('public.tbl_studiengang', 'studiengang_kz', 'LEFT');
$this->addJoin('public.tbl_status', 'tbl_status.status_kurzbz = tbl_prestudentstatus.status_kurzbz');
$this->addJoin('public.tbl_status_grund', 'statusgrund_id', 'LEFT');
$this->addJoin('bis.tbl_orgform', 'COALESCE(tbl_studienplan.orgform_kurzbz, ' . $this->dbTable . '.orgform_kurzbz, tbl_studiengang.orgform_kurzbz) = tbl_orgform.orgform_kurzbz', 'LEFT');
$this->db->where('tbl_status.status_kurzbz = tbl_prestudentstatus.status_kurzbz');
$where = array('prestudent_id' => $prestudent_id);
if ($studiensemester_kurzbz)
$where['studiensemester_kurzbz'] = $studiensemester_kurzbz;
if ($status_kurzbz)
$where['tbl_prestudentstatus.status_kurzbz'] = $status_kurzbz;
$this->addOrder('datum', 'DESC');
$this->addOrder('insertamum', 'DESC');
$this->addOrder('ext_id', 'DESC');
$this->addLimit(1);
return $this->loadWhere($where);
}
public function loadLastWithStgDetails($prestudent_id, $studiensemester_kurzbz = null, $max_date = null)
{
$this->load->config('studierendenantrag');
$lang = getUserLanguage();
$this->addSelect($this->dbTable . '.prestudent_id');
$this->addSelect($this->dbTable . '.ausbildungssemester AS semester');
$this->addSelect($this->dbTable . '.studiensemester_kurzbz');
$this->addSelect('s.matrikelnr');
$this->addSelect('ss.studienjahr_kurzbz');
$this->addSelect('pers.vorname');
$this->addSelect('pers.nachname');
$this->addSelect('TRIM(CONCAT(pers.vorname, \' \', pers.nachname)) AS name');
$this->addSelect('pers.person_id');
$this->addSelect('g.studiengang_kz');
$this->addSelect('g.bezeichnung');
$this->addSelect('o.orgform_kurzbz');
$this->addSelect(
'o.bezeichnung_mehrsprachig[(SELECT index FROM public.tbl_sprache WHERE sprache=\'' . $lang . '\')] AS orgform_bezeichnung',
false
);
$this->addJoin('public.tbl_student s', 'prestudent_id');
$this->addJoin('public.tbl_prestudent p', 'prestudent_id');
$this->addJoin('public.tbl_studiensemester ss', 'studiensemester_kurzbz');
$this->addJoin('public.tbl_person pers', 'person_id');
$this->addJoin('public.tbl_studiengang g', 'p.studiengang_kz=g.studiengang_kz');
$this->addJoin('lehre.tbl_studienplan plan', 'studienplan_id', 'LEFT');
$this->addJoin('bis.tbl_orgform o', 'COALESCE(plan.orgform_kurzbz, ' . $this->dbTable . '.orgform_kurzbz, g.orgform_kurzbz)=o.orgform_kurzbz');
$this->addOrder($this->dbTable . '.datum', 'DESC');
$this->addOrder($this->dbTable . '.insertamum', 'DESC');
$this->addOrder($this->dbTable . '.ext_id', 'DESC');
$this->addLimit(1);
if ($max_date)
$this->db->where($this->dbTable . '.insertamum <', $max_date);
$whereArr = [
$this->dbTable . '.prestudent_id' => $prestudent_id,
'g.aktiv' => true
];
if ($studiensemester_kurzbz !== null)
{
$whereArr[$this->dbTable. '.studiensemester_kurzbz'] = $studiensemester_kurzbz;
}
return $this->loadWhere($whereArr);
}
/**
* call like this:
* $this->PrestudentstatusModel->withGrund('grund_kurzbz')->update($id, $otherData);
* or:
* $this->PrestudentstatusModel->withGrund('grund_kurzbz')->insert($otherData);
* @param string $statusgrund_kurzbz
* @return object $this
*/
public function withGrund($statusgrund_kurzbz)
{
if($statusgrund_kurzbz)
$this->db->set(
'statusgrund_id',
'(SELECT statusgrund_id FROM public.tbl_status_grund WHERE statusgrund_kurzbz =' . $this->db->escape($statusgrund_kurzbz) .')',
false
);
return $this;
}
}
@@ -322,7 +322,7 @@ class Reihungstest_model extends DB_Model
JOIN lehre.tbl_studienplan ON (tbl_prestudentstatus.studienplan_id = tbl_studienplan.studienplan_id)
LEFT JOIN bis.tbl_zgv ON (ps.zgv_code = tbl_zgv.zgv_code)
WHERE rt_id = ?
AND get_rolle_prestudent(prestudent_id, rt.studiensemester_kurzbz) IN (\'Interessent\', \'Bewerber\')
AND get_rolle_prestudent(prestudent_id, rt.studiensemester_kurzbz) = \'Interessent\'
AND tbl_prestudentstatus.studiensemester_kurzbz = rt.studiensemester_kurzbz
AND bewerbung_abgeschicktamum IS NOT NULL
AND bestaetigtam IS NOT NULL
@@ -411,7 +411,7 @@ class Reihungstest_model extends DB_Model
JOIN lehre.tbl_studienplan ON (tbl_prestudentstatus.studienplan_id = tbl_studienplan.studienplan_id)
LEFT JOIN bis.tbl_zgv ON (ps.zgv_code = tbl_zgv.zgv_code)
WHERE rt.studiengang_kz = ?
AND get_rolle_prestudent(prestudent_id, rt.studiensemester_kurzbz) IN (\'Interessent\', \'Bewerber\')
AND get_rolle_prestudent(prestudent_id, rt.studiensemester_kurzbz) = \'Interessent\'
AND tbl_prestudentstatus.studiensemester_kurzbz = rt.studiensemester_kurzbz
AND bewerbung_abgeschicktamum IS NOT NULL
AND bestaetigtam IS NOT NULL
@@ -462,7 +462,7 @@ class Reihungstest_model extends DB_Model
LEFT JOIN bis.tbl_zgv ON (ps.zgv_code = tbl_zgv.zgv_code)
LEFT JOIN PUBLIC.tbl_ort ON (tbl_rt_person.ort_kurzbz = tbl_ort.ort_kurzbz)
WHERE rt_id = ?
AND get_rolle_prestudent(prestudent_id, rt.studiensemester_kurzbz) IN (\'Interessent\', \'Bewerber\')
AND get_rolle_prestudent(prestudent_id, rt.studiensemester_kurzbz) = \'Interessent\'
AND tbl_prestudentstatus.studiensemester_kurzbz = rt.studiensemester_kurzbz
AND bewerbung_abgeschicktamum IS NOT NULL
AND bestaetigtam IS NOT NULL
@@ -20,7 +20,7 @@ class Rueckstellung_model extends DB_Model
$this->addLimit(1);
$this->addJoin('tbl_rueckstellung_status', 'status_kurzbz');
$this->addSelect('*,
array_to_json(bezeichnung_mehrsprachig::varchar[])->>'.$language_index . ' as bezeichnung');
array_to_json(bezeichnung_mehrsprachig::varchar[])->>'.$language_index . 'as bezeichnung');
$this->addOrder('datum_bis', 'DESC');
$where['person_id'] = $person_id;
-10
View File
@@ -82,14 +82,4 @@ class Student_model extends DB_Model
return $result;
}
/**
* Get the FH-Email for a student (not the private kontakt email)
* @param $student_uid
* @return string
*/
public function getEmailFH($student_uid)
{
return $student_uid . '@' . DOMAIN;
}
}
@@ -30,7 +30,7 @@ class Anrechnung_model extends DB_Model
*/
public function createAnrechnungsantrag(
$prestudent_id, $studiensemester_kurzbz, $lehrveranstaltung_id,
$begruendung_id, $dms_id, $anmerkung_student = null, $begruendung_ects = null, $begruendung_lvinhalt = null
$begruendung_id, $dms_id, $anmerkung_student = null
)
{
// Start DB transaction
@@ -44,8 +44,6 @@ class Anrechnung_model extends DB_Model
'dms_id' => $dms_id,
'studiensemester_kurzbz' => $studiensemester_kurzbz,
'anmerkung_student' => $anmerkung_student,
'begruendung_ects' => $begruendung_ects,
'begruendung_lvinhalt' => $begruendung_lvinhalt,
'insertvon' => $this->_uid
));
+1 -240
View File
@@ -29,250 +29,11 @@ class Pruefung_model extends DB_Model
JOIN lehre.tbl_pruefung prfg USING (student_uid)
JOIN lehre.tbl_lehreinheit le USING (lehreinheit_id)
JOIN lehre.tbl_lehrveranstaltung lv USING (lehrveranstaltung_id)
JOIN public.tbl_studiengang stg ON prst.studiengang_kz = stg.studiengang_kz
JOIN public.tbl_studiengang stg ON prst.studiengang_kz = stg.studiengang_kz
WHERE pers.person_id = ?
AND le.studiensemester_kurzbz = ?
ORDER BY prfg.datum, pruefung_id';
return $this->execQuery($qry, array($person_id, $studiensemester_kurzbz));
}
/**
* NOTE(chris): not used
* @return string
*/
protected function loadWhereThreeExamsFailed()
{
$this->load->config('studierendenantrag');
$this->dbTable = 'lehre.tbl_pruefung p';
$sprache_index = "SELECT index FROM public.tbl_sprache WHERE sprache='" . getUserLanguage() . "' LIMIT 1";
$this->addSelect('max(p.datum) as datum');
$this->addSelect('pers.vorname');
$this->addSelect('pers.nachname');
$this->addSelect('pers.person_id');
$this->addSelect('s.matrikelnr');
$this->addSelect('g.bezeichnung');
$this->addSelect('g.studiengang_kz');
$this->addSelect('o.bezeichnung_mehrsprachig[(' . $sprache_index . ')] AS orgform', false);
$this->addSelect('ps.prestudent_id');
$this->addSelect('lv.bezeichnung as lvbezeichnung');
$this->addSelect('le.studiensemester_kurzbz');
$this->addSelect('a.typ');
$this->addSelect('campus.get_status_studierendenantrag(a.studierendenantrag_id) status');
$this->addSelect('count(1) as count');
$this->addGroupBy([
'pers.vorname',
'pers.nachname',
'pers.person_id',
's.matrikelnr',
'g.bezeichnung',
'g.studiengang_kz',
'o.bezeichnung_mehrsprachig',
'ps.prestudent_id',
'lv.bezeichnung',
'le.studiensemester_kurzbz',
'a.typ',
'a.studierendenantrag_id'
]);
$this->addJoin('lehre.tbl_note n', 'note');
$this->addJoin('lehre.tbl_lehreinheit le', 'lehreinheit_id');
$this->addJoin('lehre.tbl_lehrveranstaltung lv', 'lehrveranstaltung_id');
$this->addJoin('public.tbl_student s', 'student_uid');
$this->addJoin('public.tbl_prestudent ps', 'prestudent_id');
$this->addJoin('public.tbl_person pers', 'person_id');
$this->addJoin('public.tbl_benutzer b', 's.student_uid=b.uid');
$this->addJoin('public.tbl_studiengang g', 'ps.studiengang_kz=g.studiengang_kz');
$this->addJoin(
'public.tbl_prestudentstatus pss',
'pss.prestudent_id=ps.prestudent_id
AND pss.studiensemester_kurzbz=le.studiensemester_kurzbz
AND pss.status_kurzbz=get_rolle_prestudent(ps.prestudent_id, le.studiensemester_kurzbz)',
'LEFT'
);
$this->addJoin('lehre.tbl_studienplan plan', 'studienplan_id', 'LEFT');
$this->addJoin('bis.tbl_orgform o', 'COALESCE(plan.orgform_kurzbz, pss.orgform_kurzbz, g.orgform_kurzbz)=o.orgform_kurzbz');
$this->db->join('campus.tbl_studierendenantrag a', 'ps.prestudent_id=a.prestudent_id and a.typ = ?', 'LEFT', false);
$this->db->where("n.positiv", false);
/* $this->db->where_in("p.pruefungstyp_kurzbz1", ['kommPruef','zusKommPruef']);*/
$this->db->where_in("get_rolle_prestudent(ps.prestudent_id, null)", $this->config->item('antrag_prestudentstatus_whitelist'));
$this->db->where("g.aktiv", true);
$this->db->where('lv.studiengang_kz not in(
SELECT ps.studiengang_kz
FROM
public.tbl_prestudent ps1
JOIN public.tbl_prestudentstatus pss USING (prestudent_id)
WHERE pss.statusgrund_id in ?
AND ps.prestudent_id = ps1.prestudent_id)', null, false);
// NOTE(chris): is Wiederholer without set statusgrund (legacy?)
$this->db->where(
'(SELECT COUNT(*)
FROM (SELECT DISTINCT studiensemester_kurzbz
FROM tbl_prestudentstatus _s
WHERE ausbildungssemester=get_absem_prestudent(ps.prestudent_id, le.studiensemester_kurzbz)
AND prestudent_id=ps.prestudent_id) a) = 1',
null,
false
);
return $this->db->get_compiled_select($this->dbTable);
}
/**
* @return stdClass
*/
public function loadWhereCommitteeExamsFailed()
{
$this->load->config('studierendenantrag');
$this->dbTable = 'lehre.tbl_pruefung p';
$this->addSelect('p.datum');
$this->addJoin('lehre.tbl_note n', 'note');
$this->db->where("n.positiv", false);
$note_blacklist = $this->config->item('note_blacklist_wiederholung');
if ($note_blacklist)
$this->db->where_not_in("n.note", $note_blacklist);
$this->db->where_in("p.pruefungstyp_kurzbz", ['kommPruef','zusKommPruef']);
$this->addOrder('p.datum', 'DESC');
return $this->load();
}
/**
* @return void
*/
protected function withDetailsForStudierendenAntrag()
{
$this->load->config('studierendenantrag');
$sprache_index = "SELECT index FROM public.tbl_sprache WHERE sprache='" . getUserLanguage() . "' LIMIT 1";
$this->addSelect('pers.vorname');
$this->addSelect('pers.nachname');
$this->addSelect('pers.person_id');
$this->addSelect('s.matrikelnr');
$this->addSelect('g.bezeichnung');
$this->addSelect('g.studiengang_kz');
$this->addSelect('o.bezeichnung_mehrsprachig[(' . $sprache_index . ')] AS orgform', false);
$this->addSelect('ps.prestudent_id');
$this->addSelect('lv.bezeichnung as lvbezeichnung');
$this->addSelect('le.studiensemester_kurzbz');
$this->addSelect('a.studierendenantrag_id');
$this->addSelect('a.typ');
$this->addSelect('campus.get_status_studierendenantrag(a.studierendenantrag_id) status');
$this->addSelect('pss.ausbildungssemester');
$this->addJoin('lehre.tbl_lehreinheit le', 'lehreinheit_id');
$this->addJoin('lehre.tbl_lehrveranstaltung lv', 'lehrveranstaltung_id');
$this->addJoin('public.tbl_student s', 'student_uid');
$this->addJoin('public.tbl_prestudent ps', 'prestudent_id');
$this->addJoin('public.tbl_person pers', 'person_id');
$this->addJoin('public.tbl_benutzer b', 's.student_uid=b.uid');
$this->addJoin('public.tbl_studiengang g', 'ps.studiengang_kz=g.studiengang_kz');
$this->addJoin(
'public.tbl_prestudentstatus pss',
'pss.prestudent_id=ps.prestudent_id
AND pss.studiensemester_kurzbz=le.studiensemester_kurzbz
AND pss.status_kurzbz=get_rolle_prestudent(ps.prestudent_id, le.studiensemester_kurzbz)',
'LEFT'
);
$this->addJoin('lehre.tbl_studienplan plan', 'studienplan_id', 'LEFT');
$this->addJoin('bis.tbl_orgform o', 'COALESCE(plan.orgform_kurzbz, pss.orgform_kurzbz, g.orgform_kurzbz)=o.orgform_kurzbz');
$this->addJoin(
'campus.tbl_studierendenantrag a',
'ps.prestudent_id=a.prestudent_id and a.typ=' . $this->escape(Studierendenantrag_model::TYP_WIEDERHOLUNG),
'LEFT'
);
$this->db->where("g.aktiv", true);
$statusgruende = $this->config->item('status_gruende_wiederholer');
if (is_array($statusgruende) && !isEmptyArray($statusgruende)) {
foreach ($statusgruende as $k => $v) {
$statusgruende[$k] = $this->db->escape($v);
}
$this->db->where('lv.studiengang_kz NOT IN(
SELECT ps1.studiengang_kz
FROM
public.tbl_prestudent ps1
JOIN public.tbl_prestudentstatus pss USING (prestudent_id)
WHERE pss.statusgrund_id in (' . implode(',', $statusgruende) . ')
AND ps.prestudent_id = ps1.prestudent_id)', null, false);
}
}
/**
* @param integer $prestudent_id student_uid
*
* @return stdClass
*/
public function loadWhereCommitteeExamFailedForPrestudent($prestudent_id, $max_date = null, $studiensemester_kurzbz = null)
{
$this->withDetailsForStudierendenAntrag();
$this->db->where('ps.prestudent_id', $prestudent_id);
if ($max_date !== null) {
$this->db->where('p.datum <=', $max_date);
}
if ($studiensemester_kurzbz !== null) {
$this->db->where('le.studiensemester_kurzbz', $studiensemester_kurzbz);
}
return $this->loadWhereCommitteeExamsFailed();
}
/**
* @param string $status
* @param \DateTime $maxDate
* @param \DateTime $minDate
*
* @return stdClass
*/
public function getAllPrestudentsWhereCommitteeExamFailed($status, $maxDate, $minDate)
{
$this->withDetailsForStudierendenAntrag();
if ($maxDate)
$this->db->where("p.datum <= ", $maxDate->format('Y-m-d'));
if ($minDate)
$this->db->where("p.datum > ", $minDate->format('Y-m-d'));
$this->db->where("b.aktiv", true);
$this->db->where_in("get_rolle_prestudent(ps.prestudent_id, null)", $this->config->item('antrag_prestudentstatus_whitelist'));
if (is_array($status)) {
if (in_array(null, $status)) {
$status = array_filter($status);
if (count($status)) {
$this->db->group_start();
$this->db->where_in('campus.get_status_studierendenantrag(a.studierendenantrag_id)', $status);
$this->db->or_where('campus.get_status_studierendenantrag(a.studierendenantrag_id)', null);
$this->db->group_end();
} else {
$this->db->where('campus.get_status_studierendenantrag(a.studierendenantrag_id)', null);
}
} else {
$this->db->where_in('campus.get_status_studierendenantrag(a.studierendenantrag_id)', $status);
}
} else {
$this->db->where('campus.get_status_studierendenantrag(a.studierendenantrag_id)', $status);
}
return $this->loadWhereCommitteeExamsFailed();
}
}
@@ -1,474 +0,0 @@
<?php
class Studierendenantrag_model extends DB_Model
{
const TYP_ABMELDUNG = 'Abmeldung';
const TYP_ABMELDUNG_STGL = 'AbmeldungStgl';
const TYP_UNTERBRECHUNG = 'Unterbrechung';
const TYP_WIEDERHOLUNG = 'Wiederholung';
/**
* Constructor
*/
public function __construct()
{
parent::__construct();
$this->dbTable = 'campus.tbl_studierendenantrag';
$this->pk = 'studierendenantrag_id';
$this->load->config('studierendenantrag');
$this->load->model('education/Studierendenantragstatus_model', 'StudierendenantragstatusModel');
}
public function loadCreatedForStudiengaenge($studiengaenge, $typ)
{
return $this->loadForStudiengaenge($studiengaenge, $typ, $this->StudierendenantragstatusModel::STATUS_CREATED);
}
public function loadForStudiengaenge($studiengaenge, $typ = null, $status = null, $sql = null)
{
if ($sql == null)
$sql = "SELECT index FROM public.tbl_sprache WHERE sprache='" . getUserLanguage() . "' LIMIT 1";
$this->addSelect('UPPER(stg.typ) || UPPER(stg.kurzbz) || \' \' || stg.bezeichnung AS bezeichnung');
$this->addSelect('bezeichnung_mehrsprachig[(' . $sql . ')] AS orgform', false);
$this->addSelect('s.studierendenantrag_id');
$this->addSelect('matrikelnr');
$this->addSelect('studienjahr_kurzbz');
$this->addSelect('vorname');
$this->addSelect('nachname');
$this->addSelect('p.prestudent_id');
$this->addSelect('p.studiengang_kz');
$this->addSelect('semester');
$this->addSelect($this->dbTable . '.grund');
$this->addSelect($this->dbTable . '.datum');
$this->addSelect('datum_wiedereinstieg');
$this->addSelect($this->dbTable . '.typ');
$this->addSelect('st.studierendenantrag_statustyp_kurzbz as status');
$this->addSelect('s.insertvon as status_insertvon');
$this->addSelect('s.insertamum as status_insertamum');
$this->addSelect('dms_id');
$this->addSelect('st.bezeichnung[(' . $sql . ')] as statustyp');
$this->addJoin('public.tbl_prestudent p', 'prestudent_id');
$this->addJoin('public.tbl_student', 'prestudent_id');
$this->addJoin('public.tbl_person', 'person_id');
$this->addJoin('public.tbl_studiengang stg', 'p.studiengang_kz=stg.studiengang_kz');
$this->addJoin('public.tbl_studiensemester ss', 'studiensemester_kurzbz');
$this->addJoin(
'public.tbl_prestudentstatus ps',
'ps.prestudent_id=p.prestudent_id
AND ps.studiensemester_kurzbz=ss.studiensemester_kurzbz
AND ps.status_kurzbz=get_rolle_prestudent(p.prestudent_id, ss.studiensemester_kurzbz)',
'LEFT'
);
$this->addJoin('lehre.tbl_studienplan plan', 'studienplan_id', 'LEFT');
$this->addJoin('bis.tbl_orgform of', 'of.orgform_kurzbz=COALESCE(plan.orgform_kurzbz, ps.orgform_kurzbz, stg.orgform_kurzbz)');
$this->addJoin(
'campus.tbl_studierendenantrag_status as s',
'campus.get_status_id_studierendenantrag('. $this->dbTable .'.studierendenantrag_id) = studierendenantrag_status_id'
);
$this->addJoin('campus.tbl_studierendenantrag_statustyp as st', 'studierendenantrag_statustyp_kurzbz');
$this->db->where_in('p.studiengang_kz', $studiengaenge);
$where = [];
if ($status !== null)
$where['st.studierendenantrag_statustyp_kurzbz'] = $status;
if ($typ !== null)
$where[$this->dbTable . '.typ'] = $typ;
return $this->loadWhere($where);
}
public function loadActiveForStudiengaenge($studiengaenge)
{
// NOTE(chris): get language before changing things in the global
// db object because getUserLanguage() might use it and it should
// not have been tampered with
$sql = "SELECT index FROM public.tbl_sprache WHERE sprache='" . getUserLanguage() . "' LIMIT 1";
$this->db->group_start();
$this->db->where_not_in('s.studierendenantrag_statustyp_kurzbz', [
Studierendenantragstatus_model::STATUS_CANCELLED,
Studierendenantragstatus_model::STATUS_APPROVED,
Studierendenantragstatus_model::STATUS_REJECTED,
Studierendenantragstatus_model::STATUS_OBJECTION_DENIED,
Studierendenantragstatus_model::STATUS_DEREGISTERED,
Studierendenantragstatus_model::STATUS_PAUSE
]);
$this->db->or_group_start();
$this->db->where('s.studierendenantrag_statustyp_kurzbz', Studierendenantragstatus_model::STATUS_APPROVED);
$this->db->where('tbl_studierendenantrag.typ', Studierendenantrag_model::TYP_ABMELDUNG_STGL);
$this->db->group_end();
$this->db->group_end();
return $this->loadForStudiengaenge($studiengaenge, null, null, $sql);
}
public function loadStgsWithAntraege($studiengaenge)
{
$this->addDistinct();
$this->addSelect('UPPER(stg.typ) || UPPER(stg.kurzbz) || \' \' || stg.bezeichnung AS bezeichnung');
$this->addSelect('p.studiengang_kz');
$this->addJoin('public.tbl_prestudent p', 'prestudent_id');
$this->addJoin('public.tbl_studiengang stg', 'p.studiengang_kz=stg.studiengang_kz');
$this->addOrder('UPPER(stg.typ) || UPPER(stg.kurzbz) || \' \' || stg.bezeichnung');
$this->db->where_in('p.studiengang_kz', $studiengaenge);
return $this->load();
}
public function isInStudiengang($studierendenantrag_id, $studiengaenge)
{
$this->addJoin('public.tbl_prestudent', 'prestudent_id');
$this->db->where_in('studiengang_kz', $studiengaenge);
return $this->load($studierendenantrag_id);
}
public function loadIdAndStatusWhere($where)
{
$this->addSelect('studierendenantrag_id');
$this->addSelect('campus.get_status_studierendenantrag(studierendenantrag_id) status');
return $this->loadWhere($where);
}
public function loadWithStatusWhere($where, $types = null)
{
$lang = 'SELECT index FROM public.tbl_sprache WHERE sprache=' . $this->escape(getUserLanguage());
$this->addSelect('*');
$this->addSelect($this->dbTable . '.grund AS grund');
$this->addSelect('s.studierendenantrag_statustyp_kurzbz status');
$this->addSelect('s.insertvon status_insertvon');
$this->addSelect('t.bezeichnung[(' . $lang . ')] statustyp');
$this->addJoin(
'campus.tbl_studierendenantrag_status s',
'campus.get_status_id_studierendenantrag(' . $this->dbTable . '.studierendenantrag_id)=s.studierendenantrag_status_id'
);
$this->addJoin(
'campus.tbl_studierendenantrag_statustyp t',
's.studierendenantrag_statustyp_kurzbz=t.studierendenantrag_statustyp_kurzbz'
);
if ($types && is_array($types)) {
$this->db->where_in('typ', $types);
}
$this->addOrder('datum', 'DESC');
return $this->loadWhere($where);
}
/**
* Get the studiengang and ausbildungssemester the student was in
* for the studiensemester the antrag was committed for
*
* @param integer $antrag_id
*
* @return stdClass
*/
public function getStgAndSem($antrag_id)
{
$this->addSelect('p.studiengang_kz');
$this->addSelect('stg.bezeichnung');
$this->addSelect('s.ausbildungssemester');
$this->addSelect('plan.sprache');
$this->addSelect('COALESCE(plan.orgform_kurzbz, s.orgform_kurzbz, stg.orgform_kurzbz) AS orgform_kurzbz');
$this->addJoin(
'public.tbl_prestudentstatus s',
$this->dbTable . '.prestudent_id=s.prestudent_id
AND ' .
$this->dbTable . '.studiensemester_kurzbz=s.studiensemester_kurzbz
AND ' .
$this->dbTable . '.insertamum > s.insertamum'
);
$this->addJoin('public.tbl_prestudent p', $this->dbTable . '.prestudent_id=p.prestudent_id');
$this->addJoin('public.tbl_studiengang stg', 'studiengang_kz', 'LEFT');
$this->addJoin('lehre.tbl_studienplan plan', 'studienplan_id', 'LEFT');
$this->addOrder('s.datum', 'DESC');
$this->addOrder('s.insertamum', 'DESC');
$this->addOrder('s.ext_id', 'DESC');
$this->addLimit(1);
return $this->loadWhere([
$this->pk => $antrag_id
]);
}
/**
* Get the studiengang the student is in
*
* @param integer $antrag_id
*
* @return stdClass
*/
public function getStg($antrag_id)
{
$this->addSelect('p.studiengang_kz');
$this->addJoin('public.tbl_prestudent p', 'prestudent_id');
$this->addLimit(1);
return $this->load(
$antrag_id
);
}
public function getStgEmail($antrag_id)
{
$this->addJoin('public.tbl_prestudent p', 'prestudent_id');
$this->addJoin('public.tbl_studiengang sg', 'studiengang_kz');
$this->addSelect('sg.email');
return $this->load($antrag_id);
}
public function loadForPerson($person_id)
{
$lang = 'SELECT index FROM public.tbl_sprache WHERE sprache=' . $this->escape(getUserLanguage());
$this->addSelect('stg.bezeichnung');
$this->addSelect('bezeichnung_mehrsprachig[(' . $lang . ')] as orgform');
$this->addSelect('p.studiengang_kz');
$this->addSelect('st.studierendenantrag_statustyp_kurzbz as status');
$this->addSelect('st.bezeichnung[(' . $lang . ')] as status_bezeichnung');
$this->addSelect('p.prestudent_id');
$this->addSelect($this->dbTable . '.studierendenantrag_id');
$this->addSelect($this->dbTable . '.studiensemester_kurzbz');
$this->addSelect($this->dbTable . '.datum');
$this->addSelect($this->dbTable . '.typ');
$this->addSelect($this->dbTable . '.insertamum');
$this->addSelect($this->dbTable . '.insertvon');
$this->addSelect($this->dbTable . '.datum_wiedereinstieg');
$this->addSelect($this->dbTable . '.grund');
$this->addSelect($this->dbTable . '.dms_id');
$this->addSelect('s.insertvon AS status_insertvon');
$this->addSelect(
"(SELECT count(1) FROM campus.tbl_studierendenantrag_status WHERE studierendenantrag_id = " .
$this->dbTable .
".studierendenantrag_id AND studierendenantrag_statustyp_kurzbz = 'Genehmigt') AS isapproved",
false
);
$this->addJoin('public.tbl_prestudent p', 'prestudent_id', 'RIGHT');
$this->addJoin('public.tbl_studiengang stg', 'p.studiengang_kz=stg.studiengang_kz');
$this->addJoin(
'public.tbl_prestudentstatus ps',
'ps.prestudent_id=p.prestudent_id AND ps.studiensemester_kurzbz=' .
$this->dbTable .
'.studiensemester_kurzbz AND ps.status_kurzbz=get_rolle_prestudent(p.prestudent_id, ' .
$this->dbTable .
'.studiensemester_kurzbz)',
'LEFT'
);
$this->addJoin('lehre.tbl_studienplan plan', 'studienplan_id', 'LEFT');
$this->addJoin('bis.tbl_orgform of', 'of.orgform_kurzbz=COALESCE(plan.orgform_kurzbz, ps.orgform_kurzbz, stg.orgform_kurzbz)');
$this->addJoin(
'campus.tbl_studierendenantrag_status s',
'campus.get_status_id_studierendenantrag(' . $this->dbTable . '.studierendenantrag_id)=s.studierendenantrag_status_id',
'LEFT'
);
$this->addJoin(
'campus.tbl_studierendenantrag_statustyp st',
's.studierendenantrag_statustyp_kurzbz=st.studierendenantrag_statustyp_kurzbz',
'LEFT'
);
$this->db->where("(
SELECT status_kurzbz
FROM public.tbl_prestudentstatus
WHERE prestudent_id=p.prestudent_id
AND status_kurzbz='Student'
LIMIT 1
) IS NOT NULL", null, false);
return $this->loadWhere([
'p.person_id' => $person_id
]);
}
public function getAntraegeWhereWiedereinstiegBetween($start, $end)
{
$this->addSelect('sg.email');
$this->addSelect('vorname');
$this->addSelect('nachname');
$this->addSelect($this->dbTable.'.*');
$this->addJoin(
'campus.tbl_studierendenantrag_status s',
'campus.get_status_id_studierendenantrag(' . $this->dbTable . '.studierendenantrag_id)=s.studierendenantrag_status_id'
);
$this->addJoin('public.tbl_prestudent p', 'prestudent_id');
$this->addJoin('public.tbl_person', 'person_id');
$this->addJoin('public.tbl_studiengang sg', 'studiengang_kz');
$this->db->where('datum_wiedereinstieg >=', $start->format('Y-m-d'));
$this->db->where('datum_wiedereinstieg <=', $end->format('Y-m-d'));
return $this->loadWhere([
's.studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_APPROVED,
$this->dbTable.'.typ' => self::TYP_UNTERBRECHUNG,
]);
}
public function getWithLastStatusWhere($where)
{
$this->addJoin(
'campus.tbl_studierendenantrag_status s',
'campus.get_status_id_studierendenantrag(' . $this->dbTable . '.studierendenantrag_id)=s.studierendenantrag_status_id'
);
return $this->loadWhere($where);
}
/**
* Checks if the Prestudent has an active Unterbrechung between
* the start of the given semester and the given enddate.
* If the enddate is omitted the end of the given semester is used.
*
* @param integer $prestudent_id
* @param string $studiensemester_kurzbz
* @param string $enddate (optional)
*
* @return boolean
*/
public function hasRunningUnterbrechungBetween($prestudent_id, $studiensemester, $enddate = null)
{
$start = '(SELECT start FROM public.tbl_studiensemester WHERE studiensemester_kurzbz=' . $this->db->escape($studiensemester) . ')';
$end = $enddate
? $this->db->escape($enddate)
: '(SELECT ende FROM public.tbl_studiensemester WHERE studiensemester_kurzbz=' . $this->db->escape($studiensemester) . ')';
$this->addJoin('public.tbl_studiensemester', 'studiensemester_kurzbz');
$this->db->where([
'prestudent_id' => $prestudent_id,
'typ' => Studierendenantrag_model::TYP_UNTERBRECHUNG,
'campus.get_status_studierendenantrag(studierendenantrag_id) !=' => Studierendenantragstatus_model::STATUS_CANCELLED,
'start < ' . $end => null,
'datum_wiedereinstieg > ' . $start => null,
]);
return (boolean)$this->db->count_all_results($this->dbTable);
}
/**
* Gets free semester slots for a new Unterbrechung.
*
* @param integer $prestudent_id
* @param string $studiensemester_kurzbz (optional)
*
* @return stdClass
*/
public function getFreeSlotsForUnterbrechung($prestudent_id, $studiensemester = null)
{
$max_starters = 2;
$max_length = max(
2,
(integer)$this->config->item('unterbrecher_semester_max_length')
);
$subquery = '';
if ($studiensemester)
$subquery = 'SELECT start FROM public.tbl_studiensemester WHERE studiensemester_kurzbz=?';
else
$subquery = 'SELECT start FROM public.tbl_studiensemester WHERE studiensemester_kurzbz=public.get_stdsem_prestudent (?, null)';
$sql = "WITH numbered_sems AS (
SELECT
a.studienjahr_kurzbz AS studienjahr_kurzbz,
a.studiensemester_kurzbz AS von,
b.studiensemester_kurzbz AS bis,
a.start AS start,
b.start AS ende,
ROW_NUMBER() OVER (
PARTITION BY a.studiensemester_kurzbz
ORDER BY b.start
) AS row_number
FROM public.tbl_studiensemester a
LEFT JOIN public.tbl_studiensemester b ON (b.start > a.ende)
),
last_sems AS (
SELECT *
FROM numbered_sems
WHERE numbered_sems.row_number <= ?
)
SELECT s.von, s.bis, s.start, s.ende, studierendenantrag_id, studienjahr_kurzbz
FROM last_sems s
LEFT JOIN (
SELECT studierendenantrag_id, start, datum_wiedereinstieg AS ende
FROM campus.tbl_studierendenantrag
LEFT JOIN public.tbl_studiensemester USING(studiensemester_kurzbz)
WHERE typ=?
AND campus.get_status_studierendenantrag(studierendenantrag_id) != ?
AND prestudent_id=?
) a ON (s.start < a.ende AND s.ende > a.start)
WHERE s.start >= (" . $subquery . ")
ORDER BY s.start, s.ende
LIMIT ?;";
return $this->execQuery($sql, [
$max_length,
self::TYP_UNTERBRECHUNG,
Studierendenantragstatus_model::STATUS_CANCELLED,
$prestudent_id,
$studiensemester ?: $prestudent_id,
$max_length * $max_starters
]);
}
/**
* Returns if an Antrag is manually paused
*
* @param integer $antrag_id
*
* @return boolean
*/
public function isManuallyPaused($antrag_id)
{
$this->addJoin(
'campus.tbl_studierendenantrag_status s',
'campus.get_status_id_studierendenantrag(' . $this->dbTable . '.studierendenantrag_id)=s.studierendenantrag_status_id'
);
$this->db->where([
's.studierendenantrag_id' => $antrag_id,
's.studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_PAUSE
]);
$this->db->group_start();
$this->db->where_not_in('s.insertvon', [
Studierendenantragstatus_model::INSERTVON_DEREGISTERED,
Studierendenantragstatus_model::INSERTVON_ABMELDUNGSTGL
]);
$this->db->or_group_start();
$this->db->where('s.insertvon', Studierendenantragstatus_model::INSERTVON_ABMELDUNGSTGL);
$this->db->where('1 !=', '(
SELECT COUNT(*)%2
FROM campus.tbl_studierendenantrag_status i
WHERE i.studierendenantrag_id = s.studierendenantrag_id
AND i.insertamum > (
SELECT ii.insertamum
FROM campus.tbl_studierendenantrag_status ii
WHERE ii.studierendenantrag_id = s.studierendenantrag_id
AND ii.insertvon <> ' . $this->escape(Studierendenantragstatus_model::INSERTVON_ABMELDUNGSTGL) . '
ORDER BY ii.insertamum DESC
LIMIT 1
)
)', false);
$this->db->group_end();
$this->db->group_end();
return hasData($this->load());
}
}
@@ -1,104 +0,0 @@
<?php
class Studierendenantraglehrveranstaltung_model extends DB_Model
{
/**
* Constructor
*/
public function __construct()
{
parent::__construct();
$this->dbTable = 'campus.tbl_studierendenantrag_lehrveranstaltung';
$this->pk = 'studierendenantrag_lehrveranstaltung_id';
}
public function insertBatch($data)
{
// Check class properties
if (is_null($this->dbTable)) return error('The given database table name is not valid', EXIT_MODEL);
// DB-INSERT
$insert = $this->db->insert_batch($this->dbTable, $data);
if ($insert)
{
return success();
}
else
{
return error($this->db->error(), EXIT_DATABASE);
}
}
public function deleteWhere($where)
{
if (is_null($this->dbTable)) return error('The given database table name is not valid', EXIT_MODEL);
$delete = $this->db->delete($this->dbTable, $where);
if ($delete)
{
return success();
}
else
{
return error($this->db->error(), EXIT_DATABASE);
}
}
public function getLvsForPrestudent($prestudent_id, $studiensemester_kurzbz)
{
$this->addSelect($this->dbTable . '.*');
$this->addSelect('a.prestudent_id');
$this->addSelect('lv.bezeichnung as lv_bezeichnung');
$this->addSelect('stat.insertamum as freigabedatum');
$this->addSelect('n.bezeichnung as note_bezeichnung');
$this->addSelect('stg.bezeichnung as stg_bezeichnung');
$this->addJoin('campus.tbl_studierendenantrag a', 'studierendenantrag_id');
$this->addJoin('lehre.tbl_note n', 'note');
$this->addJoin('lehre.tbl_lehrveranstaltung lv', 'lehrveranstaltung_id');
$this->addJoin('public.tbl_prestudent ps', 'prestudent_id');
$this->addJoin('public.tbl_studiengang stg', 'ps.studiengang_kz = stg.studiengang_kz');
$this->addJoin(
'campus.tbl_studierendenantrag_status stat',
'stat.studierendenantrag_status_id = campus.get_status_id_studierendenantrag(a.studierendenantrag_id)'
);
$this->addJoin('public.tbl_student s', 'prestudent_id');
// NOTE(chris): last offizell note
$this->addJoin('(
SELECT z.*
FROM lehre.tbl_zeugnisnote z
LEFT JOIN public.tbl_studiensemester zs
USING(studiensemester_kurzbz)
JOIN (
SELECT zi.lehrveranstaltung_id, zi.student_uid, MAX(zis.start) AS start
FROM lehre.tbl_zeugnisnote zi
LEFT JOIN lehre.tbl_note zin
USING(note)
LEFT JOIN public.tbl_studiensemester zis
USING(studiensemester_kurzbz)
WHERE zin.aktiv AND zin.offiziell
GROUP BY zi.lehrveranstaltung_id, zi.student_uid
) zx
ON (
z.lehrveranstaltung_id=zx.lehrveranstaltung_id
AND z.student_uid=zx.student_uid
AND zs.start = zx.start
)) z', 'z.lehrveranstaltung_id=lv.lehrveranstaltung_id AND z.student_uid=s.student_uid', 'LEFT');
$this->addJoin('lehre.tbl_note zn', 'z.note = zn.note', 'LEFT');
$this->load->config('studierendenantrag');
$note_intern_angerechntet = $this->config->item('wiederholung_note_angerechnet');
return $this->loadWhere([
'ps.prestudent_id' => $prestudent_id,
'a.typ' => Studierendenantrag_model::TYP_WIEDERHOLUNG,
'stat.studierendenantrag_statustyp_kurzbz' => Studierendenantragstatus_model::STATUS_APPROVED,
'n.note <> ' => 0,
$this->dbTable . '.studiensemester_kurzbz' => $studiensemester_kurzbz,
'(n.note<>' . $this->db->escape($note_intern_angerechntet) . ' OR (z.note IS NOT NULL AND zn.positiv))' => null
]);
}
}
@@ -1,209 +0,0 @@
<?php
class Studierendenantragstatus_model extends DB_Model
{
const STATUS_CREATED = 'Erstellt';
const STATUS_APPROVED = 'Genehmigt';
const STATUS_REJECTED = 'Abgelehnt';
const STATUS_PASS = 'Verzichtet';
const STATUS_REOPENED = 'Offen';
const STATUS_CANCELLED = 'Zurueckgezogen';
const STATUS_LVSASSIGNED = 'Lvszugewiesen';
const STATUS_REMINDERSENT = 'EmailVersandt';
const STATUS_REQUESTSENT_1 = 'ErsteAufforderungVersandt';
const STATUS_REQUESTSENT_2 = 'ZweiteAufforderungVersandt';
const STATUS_OBJECTED = 'Beeinsprucht';
const STATUS_OBJECTION_DENIED = 'EinspruchAbgelehnt';
const STATUS_DEREGISTERED = 'Abgemeldet';
const STATUS_PAUSE = 'Pause';
const INSERTVON_ABMELDUNGSTGL = "AbmeldungStgl";
const INSERTVON_DEREGISTERED = "Studienabbruch";
/**
* Constructor
*/
public function __construct()
{
parent::__construct();
$this->dbTable = 'campus.tbl_studierendenantrag_status';
$this->pk = 'studierendenantrag_status_id';
}
public function loadWithTyp($studierendenantrag_status_id)
{
$lang = 'SELECT index FROM public.tbl_sprache WHERE sprache=' . $this->escape(getUserLanguage());
$this->addSelect($this->dbTable . '.*');
$this->addSelect('bezeichnung[(' . $lang . ')] AS typ');
$this->addJoin('campus.tbl_studierendenantrag_statustyp', 'studierendenantrag_statustyp_kurzbz');
return $this->load($studierendenantrag_status_id);
}
public function loadWithTypWhere($where)
{
$lang = 'SELECT index FROM public.tbl_sprache WHERE sprache=' . $this->escape(getUserLanguage());
$this->addSelect($this->dbTable . '.*');
$this->addSelect('bezeichnung[(' . $lang . ')] AS typ');
$this->addJoin('campus.tbl_studierendenantrag_statustyp', 'studierendenantrag_statustyp_kurzbz');
return $this->loadWhere($where);
}
public function stopAntraegeForAbmeldungStgl($antrag_id)
{
$sql = 'INSERT INTO campus.tbl_studierendenantrag_status
(studierendenantrag_id, studierendenantrag_statustyp_kurzbz, insertvon, insertamum)
SELECT studierendenantrag_id, ?, ?, (
SELECT insertamum
FROM campus.tbl_studierendenantrag_status
WHERE studierendenantrag_status_id = campus.get_status_id_studierendenantrag(?)
)
FROM campus.tbl_studierendenantrag
WHERE prestudent_id = (
SELECT prestudent_id
FROM campus.tbl_studierendenantrag
WHERE studierendenantrag_id = ?
)
AND studierendenantrag_id <> ?
AND (
(
typ = ?
AND campus.get_status_studierendenantrag(studierendenantrag_id) IN ?
) OR (
typ = ?
AND campus.get_status_studierendenantrag(studierendenantrag_id) IN ?
) OR (
typ = ?
AND campus.get_status_studierendenantrag(studierendenantrag_id) IN ?
)
)';
return $this->execQuery($sql, [
self::STATUS_PAUSE,
self::INSERTVON_ABMELDUNGSTGL,
$antrag_id,
$antrag_id,
$antrag_id,
Studierendenantrag_model::TYP_ABMELDUNG,
[
Studierendenantragstatus_model::STATUS_CREATED
],
Studierendenantrag_model::TYP_UNTERBRECHUNG,
[
Studierendenantragstatus_model::STATUS_CREATED
],
Studierendenantrag_model::TYP_WIEDERHOLUNG,
[
Studierendenantragstatus_model::STATUS_REQUESTSENT_1,
Studierendenantragstatus_model::STATUS_REQUESTSENT_2,
Studierendenantragstatus_model::STATUS_CREATED,
Studierendenantragstatus_model::STATUS_LVSASSIGNED,
Studierendenantragstatus_model::STATUS_PAUSE
],
]);
}
public function resumeAntraegeForAbmeldungStgl($antrag_id)
{
$sql = 'INSERT INTO campus.tbl_studierendenantrag_status
(studierendenantrag_id, studierendenantrag_statustyp_kurzbz, insertvon, insertamum)
SELECT studierendenantrag_id, (
SELECT studierendenantrag_statustyp_kurzbz
FROM campus.tbl_studierendenantrag_status s
WHERE s.studierendenantrag_id=a.studierendenantrag_id
AND campus.get_status_id_studierendenantrag(a.studierendenantrag_id) <> studierendenantrag_status_id
ORDER BY insertamum DESC
LIMIT 1
), ?, (
SELECT insertamum
FROM campus.tbl_studierendenantrag_status
WHERE studierendenantrag_status_id = campus.get_status_id_studierendenantrag(?)
)
FROM campus.tbl_studierendenantrag a
WHERE prestudent_id = (
SELECT prestudent_id
FROM campus.tbl_studierendenantrag
WHERE studierendenantrag_id = ?
)
AND typ <> ?
AND campus.get_status_studierendenantrag(studierendenantrag_id) = ?
';
return $this->execQuery($sql, [
self::INSERTVON_ABMELDUNGSTGL,
$antrag_id,
$antrag_id,
Studierendenantrag_model::TYP_ABMELDUNG_STGL,
Studierendenantragstatus_model::STATUS_PAUSE
]);
}
public function stopAntraegeForAbbruchBy($antrag_id)
{
$sql = 'INSERT INTO campus.tbl_studierendenantrag_status
(studierendenantrag_id, studierendenantrag_statustyp_kurzbz, insertvon, insertamum)
SELECT studierendenantrag_id, ?, ?, (
SELECT insertamum
FROM campus.tbl_studierendenantrag_status
WHERE studierendenantrag_status_id = campus.get_status_id_studierendenantrag(?)
)
FROM campus.tbl_studierendenantrag
WHERE prestudent_id = (
SELECT prestudent_id
FROM campus.tbl_studierendenantrag
WHERE studierendenantrag_id = ?
)
AND studierendenantrag_id <> ?
AND (
(
typ = ?
AND campus.get_status_studierendenantrag(studierendenantrag_id) NOT IN ?
) OR (
typ = ?
AND campus.get_status_studierendenantrag(studierendenantrag_id) NOT IN ?
) OR (
typ = ?
AND campus.get_status_studierendenantrag(studierendenantrag_id) NOT IN ?
) OR (
typ = ?
AND campus.get_status_studierendenantrag(studierendenantrag_id) NOT IN ?
)
)';
return $this->execQuery($sql, [
self::STATUS_PAUSE,
self::INSERTVON_DEREGISTERED,
$antrag_id,
$antrag_id,
$antrag_id,
Studierendenantrag_model::TYP_ABMELDUNG,
[
Studierendenantragstatus_model::STATUS_APPROVED,
Studierendenantragstatus_model::STATUS_CANCELLED
],
Studierendenantrag_model::TYP_UNTERBRECHUNG,
[
Studierendenantragstatus_model::STATUS_APPROVED,
Studierendenantragstatus_model::STATUS_CANCELLED,
Studierendenantragstatus_model::STATUS_REMINDERSENT,
Studierendenantragstatus_model::STATUS_REJECTED
],
Studierendenantrag_model::TYP_ABMELDUNG_STGL,
[
Studierendenantragstatus_model::STATUS_CANCELLED,
Studierendenantragstatus_model::STATUS_DEREGISTERED,
Studierendenantragstatus_model::STATUS_OBJECTION_DENIED
],
Studierendenantrag_model::TYP_WIEDERHOLUNG,
[
Studierendenantragstatus_model::STATUS_DEREGISTERED,
Studierendenantragstatus_model::STATUS_APPROVED
],
]);
}
}
@@ -102,7 +102,7 @@ class Zeugnisnote_model extends DB_Model
JOIN lehre.tbl_zeugnisnote zgnisnote USING (student_uid)
JOIN lehre.tbl_note note ON zgnisnote.note = note.note
JOIN lehre.tbl_lehrveranstaltung lv USING (lehrveranstaltung_id)
JOIN public.tbl_studiengang stg ON prst.studiengang_kz = stg.studiengang_kz
JOIN public.tbl_studiengang stg ON prst.studiengang_kz = stg.studiengang_kz
WHERE pers.person_id = ?
AND zgnisnote.studiensemester_kurzbz = ?";
@@ -140,83 +140,4 @@ class Zeugnisnote_model extends DB_Model
return $this->execQuery($qry, $params);
}
/**
* Gets courses (Zeugnisnoten) for a student.
* @param string $student_uid,
* @param string $studiensemester_kurzbz
*
* @return object
*/
public function getZeugnisnoten($student_uid, $studiensemester_kurzbz)
{
$params = array();
$where='';
if ($student_uid != null)
{
$where .= " AND uid=?";
$params[] = $student_uid;
}
if ($studiensemester_kurzbz !=null)
{
$where.=" AND vw_student_lehrveranstaltung.studiensemester_kurzbz= ?";
$params[] = $studiensemester_kurzbz;
}
$where2='';
if ($student_uid != null)
{
$where2 .= " AND student_uid=?";
$params[] = $student_uid;
}
if ($studiensemester_kurzbz !=null)
{
$where2 .= " AND studiensemester_kurzbz= ?";
$params[] = $studiensemester_kurzbz;
}
$qry = "SELECT vw_student_lehrveranstaltung.lehrveranstaltung_id, uid,
vw_student_lehrveranstaltung.studiensemester_kurzbz, note, punkte, uebernahmedatum, benotungsdatum,
vw_student_lehrveranstaltung.ects, vw_student_lehrveranstaltung.semesterstunden,
tbl_zeugnisnote.updateamum, tbl_zeugnisnote.updatevon, tbl_zeugnisnote.insertamum,
tbl_zeugnisnote.insertvon, tbl_zeugnisnote.ext_id,
vw_student_lehrveranstaltung.bezeichnung as lehrveranstaltung_bezeichnung,
vw_student_lehrveranstaltung.bezeichnung_english as lehrveranstaltung_bezeichnung_english,
tbl_note.bezeichnung as note_bezeichnung,
tbl_note.positiv as note_positiv,
tbl_zeugnisnote.bemerkung as bemerkung,
vw_student_lehrveranstaltung.sort,
vw_student_lehrveranstaltung.zeugnis,
vw_student_lehrveranstaltung.studiengang_kz,
vw_student_lehrveranstaltung.lv_lehrform_kurzbz,
tbl_lehrveranstaltung.sws
FROM
(
campus.vw_student_lehrveranstaltung LEFT JOIN lehre.tbl_zeugnisnote
ON(uid=student_uid
AND vw_student_lehrveranstaltung.studiensemester_kurzbz=tbl_zeugnisnote.studiensemester_kurzbz
AND vw_student_lehrveranstaltung.lehrveranstaltung_id=tbl_zeugnisnote.lehrveranstaltung_id
)
) LEFT JOIN lehre.tbl_note USING(note)
JOIN lehre.tbl_lehrveranstaltung ON(vw_student_lehrveranstaltung.lehrveranstaltung_id=tbl_lehrveranstaltung.lehrveranstaltung_id)
WHERE true $where
UNION
SELECT lehre.tbl_lehrveranstaltung.lehrveranstaltung_id,student_uid AS uid,studiensemester_kurzbz, note, punkte,
uebernahmedatum, benotungsdatum,lehre.tbl_lehrveranstaltung.ects,lehre.tbl_lehrveranstaltung.semesterstunden, tbl_zeugnisnote.updateamum, tbl_zeugnisnote.updatevon, tbl_zeugnisnote.insertamum,
tbl_zeugnisnote.insertvon, tbl_zeugnisnote.ext_id, lehre.tbl_lehrveranstaltung.bezeichnung as lehrveranstaltung_bezeichnung, lehre.tbl_lehrveranstaltung.bezeichnung_english as lehrveranstaltung_bezeichnung_english,
tbl_note.bezeichnung as note_bezeichnung, tbl_note.positiv as note_positiv, tbl_zeugnisnote.bemerkung as bemerkung, tbl_lehrveranstaltung.sort, tbl_lehrveranstaltung.zeugnis, tbl_lehrveranstaltung.studiengang_kz,
tbl_lehrveranstaltung.lehrform_kurzbz as lv_lehrform_kurzbz, tbl_lehrveranstaltung.sws
FROM
lehre.tbl_zeugnisnote
JOIN lehre.tbl_lehrveranstaltung USING (lehrveranstaltung_id)
JOIN lehre.tbl_note USING(note)
WHERE true $where2
ORDER BY sort";
return $this->execQuery($qry, $params);
}
}
@@ -511,10 +511,10 @@ class Studiengang_model extends DB_Model
public function getStudiengangTyp($studiengang_kz, $typ = null)
{
$query = "SELECT DISTINCT(sgt.*)
FROM tbl_studiengangstyp sgt JOIN tbl_studiengang sg on sgt.typ = sg.typ
FROM tbl_studiengangstyp sgt JOIN tbl_studiengang sg on sgt.typ = sg.typ
WHERE studiengang_kz IN ?";
$params = [$studiengang_kz];
$params[] = $studiengang_kz;
if (!is_null($typ))
{
@@ -524,80 +524,4 @@ class Studiengang_model extends DB_Model
return $this->execQuery($query, $params);
}
/**
* @param array $studiengang_kzs
* @param array $not_antrag_typ (optional) If the prestudent has an antrag with one of the specified types it will be excluded from the result
* @param array $prestudent_stati (optional)
*
* @return stdClass
*/
public function getAktivePrestudenten($studiengang_kzs, $not_antrag_typ = null, $query = null)
{
$this->load->config('studierendenantrag');
$sql = "SELECT index FROM public.tbl_sprache WHERE sprache='" . getUserLanguage() . "' LIMIT 1";
$this->addSelect($this->dbTable . '.studiengang_kz');
$this->addSelect($this->dbTable . '.bezeichnung');
$this->addSelect('o.orgform_kurzbz');
$this->addSelect('o.bezeichnung_mehrsprachig[(' . $sql . ')] AS orgform', false);
$this->addSelect('ps.ausbildungssemester AS semester');
$this->addSelect('ps.studiensemester_kurzbz');
$this->addSelect('p.prestudent_id');
$this->addSelect('pers.vorname');
$this->addSelect('pers.nachname');
$this->addSelect("CONCAT(UPPER(pers.nachname), ' ', pers.vorname, ' (', " . $this->dbTable . ".bezeichnung, ')') AS name");
$this->addJoin('public.tbl_prestudent p', 'studiengang_kz');
$this->addJoin(
'public.tbl_prestudentstatus ps',
'ps.prestudent_id=p.prestudent_id
AND ps.studiensemester_kurzbz=get_stdsem_prestudent(p.prestudent_id, NULL)
AND ps.ausbildungssemester=get_absem_prestudent(p.prestudent_id, NULL)
AND ps.status_kurzbz=get_rolle_prestudent(p.prestudent_id, NULL)'
);
$this->addJoin('lehre.tbl_studienplan plan', 'studienplan_id');
$this->addJoin('bis.tbl_orgform o', 'COALESCE(plan.orgform_kurzbz, ps.orgform_kurzbz, ' . $this->dbTable . '.orgform_kurzbz)=o.orgform_kurzbz');
$this->addJoin('public.tbl_person pers', 'person_id');
$this->addJoin('public.tbl_student stud', 'p.prestudent_id=stud.prestudent_id', 'LEFT');
$this->db->where_in($this->dbTable . '.studiengang_kz', $studiengang_kzs);
$this->db->where_in('ps.status_kurzbz', $this->config->item('antrag_prestudentstatus_whitelist'));
$this->db->where($this->dbTable . ".aktiv", true);
if ($not_antrag_typ !== null && is_array($not_antrag_typ)) {
foreach($not_antrag_typ as $k => $v)
$not_antrag_typ[$k] = $this->db->escape($v);
$this->addJoin(
'campus.tbl_studierendenantrag a',
'a.prestudent_id=p.prestudent_id and a.typ in ('.
implode(',', $not_antrag_typ).
") AND campus.get_status_studierendenantrag (a.studierendenantrag_id)<>'" .
Studierendenantragstatus_model::STATUS_CANCELLED . "'",
'LEFT'
);
$this->db->where('a.typ IS NULL');
}
if ($query) {
$query = explode(' ', $query);
$this->db->group_start();
foreach ($query as $q) {
$this->db->group_start();
$this->db->where('pers.vorname ILIKE', "%" . $q . "%");
$this->db->or_where('pers.nachname ILIKE', "%" . $q . "%");
$this->db->or_where('stud.student_uid ILIKE', "%" . $q . "%");
$this->db->or_where($this->dbTable . '.bezeichnung ILIKE', "%" . $q . "%");
if (is_numeric($q))
$this->db->or_where('p.prestudent_id', $q);
$this->db->group_end();
}
$this->db->group_end();
}
$this->addOrder('name');
return $this->load();
}
}
@@ -45,7 +45,7 @@ class Studienplan_model extends DB_Model
$whereArray["tbl_studienplan.sprache"] = $sprache;
}
return $this->loadWhere($whereArray);
return $this->StudienplanModel->loadWhere($whereArray);
}
public function getStudienplanLehrveranstaltung($studienplan_id, $semester)
@@ -53,54 +53,6 @@ class Studienplan_model extends DB_Model
$this->addJoin('lehre.tbl_studienplan_lehrveranstaltung', 'studienplan_id');
$this->addJoin('lehre.tbl_lehrveranstaltung', 'lehrveranstaltung_id');
$this->addOrder('tbl_lehrveranstaltung.sort');
return $this->loadWhere(array(
'studienplan_id' => $studienplan_id,
'tbl_studienplan_lehrveranstaltung.semester' => $semester
));
}
public function getStudienplanLehrveranstaltungForPrestudent($studienplan_id, $semester, $prestudent_id)
{
$lang = 'SELECT index FROM public.tbl_sprache WHERE sprache=' . $this->escape(getUserLanguage());
$sql = 'SELECT student_uid FROM public.tbl_student WHERE prestudent_id=' . $this->escape($prestudent_id);
$this->addSelect($this->dbTable . '.*');
$this->addSelect('lv.*');
$this->addSelect('COALESCE(n.bezeichnung_mehrsprachig[(' . $lang . ')], NULL) AS note');
$this->addSelect('n.positiv');
$this->addSelect('lehre.tbl_studienplan_lehrveranstaltung.studienplan_lehrveranstaltung_id');
$this->addSelect('lehre.tbl_studienplan_lehrveranstaltung.sort plan_sort');
$this->addSelect('lehre.tbl_studienplan_lehrveranstaltung.studienplan_lehrveranstaltung_id_parent');
$this->addJoin('lehre.tbl_studienplan_lehrveranstaltung', 'studienplan_id');
$this->addJoin('lehre.tbl_lehrveranstaltung lv', 'lehrveranstaltung_id');
// NOTE(chris): last offizell note
$this->addJoin('(
SELECT z.*
FROM lehre.tbl_zeugnisnote z
LEFT JOIN public.tbl_studiensemester zs
USING(studiensemester_kurzbz)
JOIN (
SELECT zi.lehrveranstaltung_id, zi.student_uid, MAX(zis.start) AS start
FROM lehre.tbl_zeugnisnote zi
LEFT JOIN lehre.tbl_note zin
USING(note)
LEFT JOIN public.tbl_studiensemester zis
USING(studiensemester_kurzbz)
WHERE zin.aktiv AND zin.offiziell
GROUP BY zi.lehrveranstaltung_id, zi.student_uid
) zx
ON (
z.lehrveranstaltung_id=zx.lehrveranstaltung_id
AND z.student_uid=zx.student_uid
AND zs.start = zx.start
)) zn', 'zn.lehrveranstaltung_id=lv.lehrveranstaltung_id AND zn.student_uid=( ' . $sql . ')', 'LEFT');
$this->addJoin('lehre.tbl_note n', 'n.note=zn.note', 'LEFT');
$this->addOrder('lehre.tbl_studienplan_lehrveranstaltung.sort');
$this->addOrder('lv.sort');
return $this->loadWhere(array(
'studienplan_id' => $studienplan_id,
'tbl_studienplan_lehrveranstaltung.semester' => $semester
@@ -204,14 +204,4 @@ class Studiensemester_model extends DB_Model
return $this->execQuery($query, array($studiensemester_kurzbz));
}
public function getAktAndFutureSemester()
{
$query = 'SELECT studiensemester_kurzbz
FROM public.tbl_studiensemester
WHERE start >= NOW() OR (start <= NOW() AND ende >= NOW())
ORDER BY start';
return $this->execQuery($query);
}
}
@@ -180,60 +180,4 @@ class Benutzerfunktion_model extends DB_Model
return $this->execQuery($query, $parameters_array);
}
public function insertBenutzerfunktion($Json)
{
unset($Json['benutzerfunktion_id']);
unset($Json['updateamum']);
$Json['insertvon'] = getAuthUID();
$Json['insertamum'] = $this->escape('NOW()');
if ($Json['datum_bis']=='')
{
unset($Json['datum_bis']);
}
$result = $this->insert($Json);
if (isError($result))
{
return error($result->msg, EXIT_ERROR);
}
$record = $this->load($result->retval);
return $record;
}
function updateBenutzerfunktion($funktionJson)
{
$funktionJson['updatevon'] = getAuthUID();
$funktionJson['updateamum'] = $this->escape('NOW()');
$result = $this->update($funktionJson['benutzerfunktion_id'], $funktionJson);
if (isError($result))
{
return error($result->msg, EXIT_ERROR);
}
$result = $this->load($funktionJson['benutzerfunktion_id']);
return $result;
}
function deleteBenutzerfunktion($funktionJson)
{
$result = $this->delete($funktionJson);
if (isError($result))
{
return error($result->msg, EXIT_ERROR);
}
return success($funktionJson);
}
}
@@ -1,15 +0,0 @@
<?php
class Kennzeichen_model extends DB_Model
{
/**
* Constructor
*/
public function __construct()
{
parent::__construct();
$this->dbTable = 'public.tbl_kennzeichen';
$this->pk = 'kennzeichen_id';
}
}
+8 -48
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/>.
*/
class Person_model extends DB_Model
{
/**
@@ -25,7 +8,6 @@ class Person_model extends DB_Model
public function __construct()
{
parent::__construct();
$this->dbTable = 'public.tbl_person';
$this->pk = 'person_id';
@@ -88,7 +70,7 @@ class Person_model extends DB_Model
if (isset($person['svnr']) && $person['svnr'] != '')
{
$this->PersonModel->addOrder('svnr', 'DESC');
$result = $this->PersonModel->loadWhere(array(
$result = $this->PersonModel->loadWhere(array(
'person_id != ' => $person['person_id'],
'SUBSTRING(svnr FROM 1 FOR 10) = ' => $person['svnr'])
);
@@ -156,8 +138,7 @@ class Person_model extends DB_Model
'lower(nachname) like '.$this->db->escape('%'.$filter.'%')."
OR lower(vorname) like ".$this->db->escape('%'.$filter.'%')."
OR lower(nachname || ' ' || vorname) like ".$this->db->escape('%'.$filter.'%')."
OR lower(vorname || ' ' || nachname) like ".$this->db->escape('%'.$filter.'%')
);
OR lower(vorname || ' ' || nachname) like ".$this->db->escape('%'.$filter.'%'));
return $result;
}
@@ -171,12 +152,8 @@ class Person_model extends DB_Model
*/
public function getPersonStammdaten($person_id, $zustellung_only = false)
{
$this->addSelect('public.tbl_person.*,
tbl_person.staatsbuergerschaft AS staatsbuergerschaft_code,
tbl_person.geburtsnation AS geburtsnation_code,
s.kurztext as staatsbuergerschaft,
g.kurztext as geburtsnation'
);
$this->addSelect('public.tbl_person.*, tbl_person.staatsbuergerschaft AS staatsbuergerschaft_code, tbl_person.geburtsnation AS geburtsnation_code,
s.kurztext as staatsbuergerschaft, g.kurztext as geburtsnation');
$this->addJoin('bis.tbl_nation s', 'public.tbl_person.staatsbuergerschaft = s.nation_code', 'LEFT');
$this->addJoin('bis.tbl_nation g', 'public.tbl_person.geburtsnation = g.nation_code', 'LEFT');
@@ -281,8 +258,7 @@ class Person_model extends DB_Model
*/
public function getFullName($uid)
{
$result = getData($this->getByUid($uid))[0];
if (!$result)
if (!$result = getData($this->getByUid($uid))[0])
{
show_error('Failed loading person');
}
@@ -350,29 +326,13 @@ class Person_model extends DB_Model
SELECT p2.person_id
FROM tbl_person p1
JOIN tbl_prestudent ps ON p1.person_id = ps.person_id
INNER JOIN (
SELECT vorname, nachname, gebdatum, person.person_id
FROM tbl_person person
JOIN tbl_prestudent sps ON person.person_id = sps.person_id
) p2
SELECT vorname, nachname, gebdatum, person_id
FROM tbl_person
) p2
ON (lower(p1.vorname) = lower(p2.vorname) AND lower(p1.nachname) = lower(p2.nachname) AND p1.gebdatum = p2.gebdatum)
WHERE p1.person_id != p2.person_id AND (p1.person_id = ?)";
return $this->execQuery($qry, array($person_id, $person_id, $person_id));
}
public function loadPrestudent($prestudent_id)
{
$this->addSelect($this->dbTable . '.*');
$this->addJoin('public.tbl_prestudent p', 'person_id');
$this->addLimit(1);
return $this->loadWhere([
'prestudent_id' => $prestudent_id
]);
}
}
@@ -144,15 +144,10 @@ class Mitarbeiter_model extends DB_Model
* Checks if alias exists
* @param $kurzbz
*/
public function kurzbzExists($kurzbz, $uid=null)
public function kurzbzExists($kurzbz)
{
$this->addSelect('1');
$where = array('kurzbz' => $kurzbz);
if ($uid != null)
{
$where['mitarbeiter_uid<>'] = $uid;
}
$result = $this->loadWhere($where);
$result = $this->loadWhere(array('kurzbz' => $kurzbz));
if (isSuccess($result))
{
@@ -176,6 +171,7 @@ class Mitarbeiter_model extends DB_Model
*/
public function generateKurzbz($uid)
{
$kurzbz = '';
$this->addLimit(1);
$this->addSelect('vorname, nachname');
$this->addJoin('public.tbl_benutzer', 'tbl_mitarbeiter.mitarbeiter_uid = tbl_benutzer.uid');
@@ -185,35 +181,25 @@ class Mitarbeiter_model extends DB_Model
if (hasData($nameresult))
{
$kurzbzdata = getData($nameresult);
$genKurzbz = $this->generateKurzbzHelper($kurzbzdata[0]->vorname, $kurzbzdata[0]->nachname);
$nachname_clean = sanitizeProblemChars($kurzbzdata[0]->nachname);
$vorname_clean = sanitizeProblemChars($kurzbzdata[0]->vorname);
return $genKurzbz;
}
return error('No Kurzbezeichnung could be generated');
}
for ($nn = 6, $vn = 2; $nn != 0; $nn--, $vn++)
{
$kurzbz = mb_substr($nachname_clean, 0, $nn);
$kurzbz .= mb_substr($vorname_clean, 0, $vn);
public function generateKurzbzHelper($vorname, $nachname)
{
$nachname_clean = sanitizeProblemChars($nachname);
$vorname_clean = sanitizeProblemChars($vorname);
$kurzbz = '';
$kurzbzexists = $this->kurzbzExists($kurzbz);
for ($nn = 6, $vn = 2; $nn != 0; $nn--, $vn++)
{
$kurzbz = mb_substr($nachname_clean, 0, $nn);
$kurzbz .= mb_substr($vorname_clean, 0, $vn);
if (hasData($kurzbzexists) && !getData($kurzbzexists)[0])
break;
}
$kurzbzexists = $this->kurzbzExists($kurzbz);
if (hasData($kurzbzexists) && !getData($kurzbzexists)[0])
break;
if (hasData($kurzbzexists) && getData($kurzbzexists)[0])
return error('No Kurzbezeichnung could be generated');
}
$kurzbzexists = $this->kurzbzExists($kurzbz);
if (hasData($kurzbzexists) && getData($kurzbzexists)[0])
return error('No Kurzbezeichnung could be generated');
return success($kurzbz);
}
}
@@ -1,17 +0,0 @@
<?php
class Stundensatz_model extends DB_Model
{
/**
* Constructor
*/
public function __construct()
{
parent::__construct();
$this->dbTable = 'hr.tbl_stundensatz';
$this->pk = 'stundensatz_id';
$this->hasSequence = true;
}
}
@@ -1,16 +0,0 @@
<?php
class Stundensatztyp_model extends DB_Model
{
/**
* Constructor
*/
public function __construct()
{
parent::__construct();
$this->dbTable = 'hr.tbl_stundensatztyp';
$this->pk = 'stundensatztyp';
}
}
@@ -21,26 +21,4 @@ class Zeitaufzeichnung_model extends DB_Model
return $this->execQuery($qry);
}
public function getFullInterval($uid, $fromDate, $toDate)
{
$qry = <<<EOL
SELECT d.dates, z.*
FROM
(SELECT
*, to_char ((ende-start),'HH24:MI') as diff,
(SELECT (to_char(sum(ende-start),'DD')::integer)*24+to_char(sum(ende-start),'HH24')::integer || ':' || to_char(sum(ende-start),'MI')
FROM campus.tbl_zeitaufzeichnung
WHERE uid=? and start between ? AND ?) as summe
FROM campus.tbl_zeitaufzeichnung
WHERE uid=? AND (aktivitaet_kurzbz != 'DienstreiseMT' or aktivitaet_kurzbz is null) AND start between ? AND ?) as z
RIGHT JOIN (select generate_series ( ?::timestamp , ?::timestamp , '1 day'::interval) :: date as dates) d on date(z.ende) = d.dates
ORDER BY d.dates desc, z.start desc
EOL;
return $this->execQuery($qry, array($uid, $fromDate, $toDate, $uid, $fromDate, $toDate, $fromDate, $toDate));
}
}
+1 -18
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/>.
*/
class PersonLog_model extends DB_Model
{
/**
@@ -34,7 +17,7 @@ class PersonLog_model extends DB_Model
* @param array $data Data of Log Entry to save.
* @return success object if true
*/
public function insert($data, $encryptedColumns = null)
public function insert($data)
{
$result = $this->db->insert($this->dbTable, $data);
if ($result)
@@ -1,245 +0,0 @@
<?php
class Dienstverhaeltnis_model extends DB_Model
{
public function __construct()
{
parent::__construct();
$this->dbTable = 'hr.tbl_dienstverhaeltnis';
$this->pk = 'dienstverhaeltnis_id';
}
/**
* @return list of DV
*/
public function getDVByPersonUID($uid, $oe_kurzbz=null, $datum=null)
{
$result = null;
$qry = "
SELECT
dv.dienstverhaeltnis_id,
tbl_benutzer.uid,
tbl_mitarbeiter.personalnummer,
tbl_mitarbeiter.kurzbz,
tbl_mitarbeiter.lektor,
tbl_mitarbeiter.fixangestellt,
tbl_person.person_id,
tbl_benutzer.alias,
org.oe_kurzbz,
org.bezeichnung oe_bezeichnung,
dv.von,
dv.bis,
dv.vertragsart_kurzbz,
dv.updateamum,
dv.updatevon
FROM tbl_mitarbeiter
JOIN tbl_benutzer ON tbl_mitarbeiter.mitarbeiter_uid::text = tbl_benutzer.uid::text
JOIN tbl_person USING (person_id)
JOIN hr.tbl_dienstverhaeltnis dv ON(tbl_benutzer.uid::text = dv.mitarbeiter_uid::text)
JOIN public.tbl_organisationseinheit org USING(oe_kurzbz)
WHERE tbl_benutzer.uid=?";
$data = array($uid);
if(!is_null($oe_kurzbz))
{
$qry.=" AND oe_kurzbz=?";
$data[] = $oe_kurzbz;
}
if (!is_null($datum))
{
$qry.=" AND ? BETWEEN dv.von AND COALESCE(dv.bis, '2999-12-31')";
$data[] = $datum;
}
$qry .="
ORDER BY dv.von desc
";
return $this->execQuery($qry, $data);
}
public function getDVByID($dvid) {
$this->addSelect('hr.tbl_dienstverhaeltnis.*, public.tbl_organisationseinheit.bezeichnung as unternehmen');
$this->addJoin('public.tbl_organisationseinheit', 'hr.tbl_dienstverhaeltnis.oe_kurzbz = public.tbl_organisationseinheit.oe_kurzbz');
$result = $this->load($dvid);
if (hasData($result)) {
return $result;
}
return error('could not fetch DV by ID');
}
public function getCurrentDVByPersonUID($uid, $dateAsUnixTS)
{
$date = DateTime::createFromFormat( 'U', $dateAsUnixTS );
$datestring = $date->format("Y-m-d");
$qry = "
SELECT
dv.dienstverhaeltnis_id,
tbl_benutzer.uid,
tbl_mitarbeiter.personalnummer,
tbl_mitarbeiter.kurzbz,
tbl_mitarbeiter.lektor,
tbl_mitarbeiter.fixangestellt,
tbl_person.person_id,
tbl_benutzer.alias,
dv.von,
dv.bis,
dv.vertragsart_kurzbz,
dv.updateamum,
dv.updatevon
FROM tbl_mitarbeiter
JOIN tbl_benutzer ON tbl_mitarbeiter.mitarbeiter_uid::text = tbl_benutzer.uid::text
JOIN tbl_person USING (person_id)
JOIN hr.tbl_dienstverhaeltnis dv ON(tbl_benutzer.uid::text = dv.mitarbeiter_uid::text)
WHERE tbl_benutzer.uid=? and (dv.von<=? and (dv.bis is null OR dv.bis>=?))
ORDER BY dv.von desc
";
return $this->execQuery($qry, array($uid, $datestring, $datestring));
}
public function isOverlappingExistingDV($mitarbeiter_uid, $oe_kurzbz, $von, $bis, $dvid=null)
{
$params = array($mitarbeiter_uid, $oe_kurzbz, $von, $bis, $von, $bis);
$dvidclause = '';
if (intval($dvid) > 0)
{
$params = array_merge($params, array($dvid, $dvid));
$dvidclause = <<<EODVIDC
AND (
SELECT
COUNT(*) AS karenzen
FROM
hr.tbl_vertragsbestandteil vb
WHERE
vb.dienstverhaeltnis_id = ?
AND
vb.vertragsbestandteiltyp_kurzbz = 'karenz'
AND
dv.von::date >= COALESCE(vb.von, '1970-01-01'::date)
AND
COALESCE(dv.bis::date, '2170-12-31'::date) <= COALESCE(vb.bis, '2170-12-31')
) = 0
AND dv.dienstverhaeltnis_id != ?
EODVIDC;
}
$query = <<<EOSQL
SELECT
count(*) AS dvcount
FROM
hr.tbl_dienstverhaeltnis dv
WHERE
dv.mitarbeiter_uid = ?
AND
dv.oe_kurzbz = ?
AND
dv.vertragsart_kurzbz NOT IN ('werkvertrag', 'studentischehilfskr')
AND
?::date <= COALESCE(dv.bis, '2170-12-31'::date)
AND
COALESCE(?::date, '2170-12-31'::date) >= dv.von
AND (
SELECT
COUNT(*) AS karenzen
FROM
hr.tbl_vertragsbestandteil vb
WHERE
vb.dienstverhaeltnis_id = dv.dienstverhaeltnis_id
AND
vb.vertragsbestandteiltyp_kurzbz = 'karenz'
AND
?::date >= COALESCE(vb.von, '1970-01-01'::date)
AND
COALESCE(?::date, '2170-12-31'::date) <= COALESCE(vb.bis, '2170-12-31')
) = 0
{$dvidclause}
EOSQL;
$ret = $this->execReadOnlyQuery($query, $params);
if( ($dvcount = getData($ret)) && ($dvcount[0]->dvcount > 0) ) {
return true;
}
return false;
}
public function getDVByPersonUIDOverlapping($uid, $oe_kurzbz=null, $beginn=null, $ende=null)
{
$result = null;
$qry = "
SELECT
dv.dienstverhaeltnis_id,
tbl_benutzer.uid,
tbl_mitarbeiter.personalnummer,
tbl_mitarbeiter.kurzbz,
tbl_mitarbeiter.lektor,
tbl_mitarbeiter.fixangestellt,
tbl_person.person_id,
tbl_benutzer.alias,
org.oe_kurzbz,
org.bezeichnung oe_bezeichnung,
dv.von,
dv.bis,
dv.vertragsart_kurzbz,
dv.updateamum,
dv.updatevon
FROM tbl_mitarbeiter
JOIN tbl_benutzer ON tbl_mitarbeiter.mitarbeiter_uid::text = tbl_benutzer.uid::text
JOIN tbl_person USING (person_id)
JOIN hr.tbl_dienstverhaeltnis dv ON(tbl_benutzer.uid::text = dv.mitarbeiter_uid::text)
JOIN public.tbl_organisationseinheit org USING(oe_kurzbz)
WHERE tbl_benutzer.uid=?";
$data = array($uid);
if(!is_null($oe_kurzbz))
{
$qry.=" AND oe_kurzbz=?";
$data[] = $oe_kurzbz;
}
if (!is_null($beginn) && !is_null($ende))
{
$qry.=" AND (?,?) OVERLAPS (dv.von, COALESCE(dv.bis, '2999-12-31'))";
$data[] = $beginn;
$data[] = $ende;
}
$qry .="
ORDER BY dv.von desc
";
return $this->execQuery($qry, $data);
}
public function fetchDienstverhaeltnisse($unternehmen, $stichtag=null, $mitarbeiteruid=null) {
$where = "oe_kurzbz = " . $this->escape($unternehmen);
if( !is_null($stichtag) )
{
$where .= " AND " . $this->escape($stichtag) . " BETWEEN COALESCE(von, '1970-01-01') AND COALESCE(bis, '2070-12-31')";
}
if( !is_null($mitarbeiteruid) )
{
$where .= " AND mitarbeiter_uid = " . $this->escape($mitarbeiteruid);
}
$res = $this->loadWhere($where);
$dvs = array();
if(hasData($res) )
{
$dvs = getData($res);
}
return $dvs;
}
}
@@ -1,147 +0,0 @@
<?php
require_once __DIR__ . '/IEncryption.php';
use vertragsbestandteil\Gehaltsbestandteil;
class Gehaltsbestandteil_model extends DB_Model implements IEncryption
{
public function __construct()
{
parent::__construct();
$this->dbTable = 'hr.tbl_gehaltsbestandteil';
$this->pk = 'gehaltsbestandteil_id';
}
public function getEncryptedColumns(): array
{
return array(
'grundbetrag' => array(
DB_Model::CRYPT_CAST => 'numeric',
DB_Model::CRYPT_PASSWORD_NAME => 'ENCRYPTIONKEYGEHALT'
),
'betrag_valorisiert' => array(
DB_Model::CRYPT_CAST => 'numeric',
DB_Model::CRYPT_PASSWORD_NAME => 'ENCRYPTIONKEYGEHALT'
)
);
}
public function getCurrentGBTByDV($dienstverhaeltnis_id, $dateAsUnixTS)
{
$date = DateTime::createFromFormat( 'U', $dateAsUnixTS );
$datestring = $date->format("Y-m-d");
$qry = "
SELECT
gehaltsbestandteil_id,
gbt.von,
gbt.bis,
gbt.anmerkung,
gbt.dienstverhaeltnis_id,
gehaltstyp_kurzbz,
valorisierungssperre,
gbt.valorisierung,
grundbetrag as grund_betrag_decrypted,
betrag_valorisiert as betrag_val_decrypted,
gt.bezeichnung as gehaltstyp_bezeichnung,
vb.vertragsbestandteiltyp_kurzbz,
bf.funktion_kurzbz,
bf.oe_kurzbz,
fkt.beschreibung as fkt_beschreibung,
fb.bezeichnung as fb_bezeichnung,
org.bezeichnung as org_bezeichnung,
freitext.freitexttyp_kurzbz,
freitext.titel as freitext_titel
FROM hr.tbl_gehaltsbestandteil gbt LEFT JOIN hr.tbl_gehaltstyp gt using(gehaltstyp_kurzbz)
LEFT JOIN hr.tbl_vertragsbestandteil vb using(vertragsbestandteil_id)
LEFT JOIN hr.tbl_vertragsbestandteil_funktion vbf using(vertragsbestandteil_id)
LEFT JOIN public.tbl_benutzerfunktion bf using(benutzerfunktion_id)
LEFT JOIN public.tbl_funktion fkt using(funktion_kurzbz)
LEFT JOIN public.tbl_fachbereich fb using(fachbereich_kurzbz)
LEFT JOIN public.tbl_organisationseinheit org on (bf.oe_kurzbz=org.oe_kurzbz)
LEFT JOIN hr.tbl_vertragsbestandteil_freitext freitext on(vb.vertragsbestandteil_id=freitext.vertragsbestandteil_id)
WHERE gbt.dienstverhaeltnis_id=? AND
(gbt.von<=? and (gbt.bis is null OR gbt.bis>=?))
ORDER BY gt.sort
";
return $this->execQuery($qry,
array($dienstverhaeltnis_id, $datestring, $datestring),
$this->getEncryptedColumns());
}
public function getGBTChartDataByDV_old($dienstverhaeltnis_id)
{
$qry = "
WITH gbt as
(select von,bis,grundbetrag as grund_betrag_decrypted from hr.tbl_gehaltsbestandteil where dienstverhaeltnis_id=?)
select von,bis, (select sum(gbt.grund_betrag_decrypted) as sum_betrag
from gbt where gbt.von<=gbtmeta.von and (gbt.bis is null or gbt.bis>=gbtmeta.von)
) as summe from gbt as gbtmeta order by von,bis
";
return $this->execQuery($qry,
array($dienstverhaeltnis_id),
$this->getEncryptedColumns());
}
public function getGehaltsbestandteile($dienstverhaeltnis_id, $stichtag=null, $includefuture=false)
{
$stichtagclause = '';
if( !is_null($stichtag) )
{
$date = strftime('%Y-%m-%d', strtotime($stichtag));
$stichtagclause = 'AND (' . $this->escape($date)
. ' BETWEEN COALESCE(von, \'1970-01-01\'::date)'
. ' AND COALESCE(bis, \'2170-01-01\'::date)';
if( $includefuture )
{
$stichtagclause .= ' OR COALESCE(von, \'1970-01-01\'::date) > '
. $this->escape($date);
}
$stichtagclause .= ')';
}
$this->addSelect('*');
$where = <<<EOSQL
dienstverhaeltnis_id = {$this->escape($dienstverhaeltnis_id)}
{$stichtagclause}
EOSQL;
$query = $this->loadWhere(
$where,
$this->getEncryptedColumns()
);
$gehaltsbestandteile = array();
if( null !== ($rows = getData($query)) )
{
foreach( $rows as $row ) {
$tmpgb = new Gehaltsbestandteil();
$tmpgb->hydrateByStdClass($row, true);
$gehaltsbestandteile[] = $tmpgb;
}
}
return $gehaltsbestandteile;
}
public function getGehaltsbestandteil($id)
{
$this->addSelect('*');
$query = $this->load($id, $this->getEncryptedColumns());
$gehaltsbestandteil = null;
if( null !== ($row = getData($query)) )
{
$gehaltsbestandteil = new Gehaltsbestandteil();
$gehaltsbestandteil->hydrateByStdClass($row[0], true);
}
return $gehaltsbestandteil;
}
}
@@ -1,7 +0,0 @@
<?php
interface IEncryption {
public function getEncryptedColumns(): array;
}
@@ -1,51 +0,0 @@
<?php
class VertragsbestandteilFreitext_model extends DB_Model
{
public function __construct()
{
parent::__construct();
$this->dbTable = 'hr.tbl_vertragsbestandteil_freitext';
$this->pk = 'vertragsbestandteil_id';
}
public function countOverlappingVBFreitextsOfSameType(vertragsbestandteil\VertragsbestandteilFreitext $vbft)
{
$notselfclause = (intval($vbft->getVertragsbestandteil_id()) > 0)
? 'AND v.vertragsbestandteil_id <> ' . $this->escape($vbft->getVertragsbestandteil_id())
: '';
$sql = <<<EOSQL
SELECT
count(*) AS overlappingvbs
FROM
hr.tbl_vertragsbestandteil v
JOIN
hr.tbl_vertragsbestandteil_freitext vbft USING(vertragsbestandteil_id)
WHERE
v.dienstverhaeltnis_id = ?
AND
v.vertragsbestandteiltyp_kurzbz = ?
AND
vbft.freitexttyp_kurzbz = ?
AND
COALESCE(?::date, '2170-12-31'::date) >= COALESCE(v.von, '1970-01-01'::date)
AND
?::date <= COALESCE(v.bis, '2170-12-31')
{$notselfclause}
EOSQL;
$ret = $this->execReadOnlyQuery($sql, array(
$vbft->getDienstverhaeltnis_id(),
$vbft->getVertragsbestandteiltyp_kurzbz(),
$vbft->getFreitexttypKurzbz(),
$vbft->getBis(),
$vbft->getVon()
));
if( null === ($vbcount = getData($ret)) ) {
throw new Exception('failed to fetch overlappingvbs count');
}
return $vbcount[0]->overlappingvbs;
}
}
@@ -1,12 +0,0 @@
<?php
class VertragsbestandteilFreitexttyp_model extends DB_Model
{
public function __construct()
{
parent::__construct();
$this->dbTable = 'hr.tbl_vertragsbestandteil_freitexttyp';
$this->pk = 'freitexttyp_kurzbz';
}
}
@@ -1,35 +0,0 @@
<?php
/**
* Description of VertragsbestandteilFunktion_model
*
* @author bambi
*/
class VertragsbestandteilFunktion_model extends DB_Model
{
/**
* Constructor
*/
public function __construct()
{
parent::__construct();
$this->dbTable = 'hr.tbl_vertragsbestandteil_funktion';
$this->pk = 'vertragsbestandteil_id';
}
public function isBenutzerfunktionAlreadyAttachedToAnotherVB($benutzerfunktion_id, $vertragsbestandteil_id)
{
$where = array('benutzerfunktion_id' => $benutzerfunktion_id);
if( intval($vertragsbestandteil_id) > 0 )
{
$where['vertragsbestandteil_id != '] = $vertragsbestandteil_id;
}
$this->addSelect('count(*) AS vbscount');
$res = $this->loadWhere($where);
if(isError($res))
{
throw new Exception('failed to check if benutzerfunktionid is already attached to another vertragsbestanteil');
}
$count = (getData($res))[0]->vbscount;
return $count > 0;
}
}
@@ -1,14 +0,0 @@
<?php
class VertragsbestandteilKarenz_model extends DB_Model
{
/**
* Constructor
*/
public function __construct()
{
parent::__construct();
$this->dbTable = 'hr.tbl_vertragsbestandteil_karenz';
$this->pk = 'vertragsbestandteil_id';
}
}
@@ -1,14 +0,0 @@
<?php
class VertragsbestandteilKuendigungsfrist_model extends DB_Model
{
/**
* Constructor
*/
public function __construct()
{
parent::__construct();
$this->dbTable = 'hr.tbl_vertragsbestandteil_kuendigungsfrist';
$this->pk = 'vertragsbestandteil_id';
}
}
@@ -1,18 +0,0 @@
<?php
/**
* Description of VertragsbestandteilStunden_model
*
* @author bambi
*/
class VertragsbestandteilStunden_model extends DB_Model
{
/**
* Constructor
*/
public function __construct()
{
parent::__construct();
$this->dbTable = 'hr.tbl_vertragsbestandteil_stunden';
$this->pk = 'vertragsbestandteil_id';
}
}

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