Merge branch 'master' into feature-36555/Studstatus_HinweistextFAS_Pruefungsdatum

application/config/migratecontract.php

@@ -0,0 +1,36 @@
+<?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');
+
+$config['migratecontract_oe_default'] = 'TODO_OE_DEFAULT';
+
+$config['migratecontract_matching_ba1_vertragsart'] = array(
+    '101'=>'dvbund',
+    '102'=>'dvanderengk',
+    '103'=>'echterdv',
+    '104'=>'studentischehilfskr',
+    '105'=>'externerlehrender',
+    '106'=>'dvanderenbet',
+    '107'=>'werkvertrag',
+    '108'=>'studentischehilfskr',
+    '109'=>'ueberlassungsvertrag',
+    '110'=>'echterfreier',
+    '111'=>'echterdv' //All-In
+);

application/controllers/api/frontend/fas/studstatus/Wiederholung.php

@@ -0,0 +1,163 @@
+<?php
+/**
+ * Copyright (C) 2024 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');
+
+
+/**
+ * This controller operates between (interface) the JS (FAS) and the AntragLib (back-end)
+ * This controller works with calls on the HTTP GET or POST and the output is always RDF
+ */
+class Wiederholung extends Auth_Controller
+{
+
+	/**
+	 * Calls the parent's constructor and loads the FilterCmptLib
+	 */
+	public function __construct()
+	{
+		parent::__construct([
+			'getLvs' => ['student/studierendenantrag:r', 'student/noten:r'],
+			'moveLvsToZeugnis' => ['student/studierendenantrag:w', 'student/noten:w']
+		]);
+
+		// Libraries
+		$this->load->library('AntragLib');
+
+		// Load language phrases
+		$this->loadPhrases([
+			'global',
+			'studierendenantrag'
+		]);
+	}
+
+	//------------------------------------------------------------------------------------------------------------------
+	// Public methods
+
+	public function getLvs($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 $result;
+		$lvs = $result->retval;
+
+		$rdf_url = 'http://www.technikum-wien.at/antragnote';
+
+		$this->load->view('lehre/Antrag/Wiederholung/getLvs.rdf.php', [
+			'url' => $rdf_url,
+			'lvs' => $lvs
+		]);
+	}
+
+	public function moveLvsToZeugnis()
+	{
+		$anzahl = $this->input->post('anzahl');
+		$student_uid = $this->input->post('student_uid');
+		$this->load->model('education/Studierendenantraglehrveranstaltung_model', 'StudierendenantraglehrveranstaltungModel');
+		$this->load->model('education/Zeugnisnote_model', 'ZeugnisnoteModel');
+
+		$errormsg = array();
+
+		for($i=0; $i<$anzahl; $i++)
+		{
+			$id = $this->input->post('studierendenantrag_lehrveranstaltung_id_' . $i);
+			$result =$this->StudierendenantraglehrveranstaltungModel->load($id);
+			if(isError($result))
+			{
+				$errormsg[] = getError($result);
+			}
+			elseif(!hasData($result))
+			{
+				$errormsg[] = $this->p->t('studierendenantrag', 'error_no_lv_in_application');
+			}
+			else
+			{
+				$antragLv = getData($result)[0];
+				$result= $this->ZeugnisnoteModel->load([
+					'lehrveranstaltung_id'=> $antragLv->lehrveranstaltung_id,
+					'student_uid'=> $student_uid,
+					'studiensemester_kurzbz' => $antragLv->studiensemester_kurzbz
+				]);
+				if(isError($result))
+				{
+					$errormsg[] = getError($result);
+				}
+				else
+				{
+					if (hasData($result))
+					{
+						$result = $this->ZeugnisnoteModel->update(
+							[
+								'lehrveranstaltung_id'=> $antragLv->lehrveranstaltung_id,
+								'student_uid'=> $student_uid,
+								'studiensemester_kurzbz' => $antragLv->studiensemester_kurzbz
+							],
+							[
+								'note'=> $antragLv->note,
+								'uebernahmedatum' => date('c'),
+								'benotungsdatum' => $antragLv->insertamum,
+								'updateamum' => date('c'),
+								'bemerkung'=>$antragLv->anmerkung,
+								'updatevon'=>getAuthUID()
+							]
+						);
+					}
+					else
+					{
+						$result = $this->ZeugnisnoteModel->insert([
+							'lehrveranstaltung_id'=> $antragLv->lehrveranstaltung_id,
+							'student_uid'=> $student_uid,
+							'studiensemester_kurzbz' => $antragLv->studiensemester_kurzbz,
+							'note'=> $antragLv->note,
+							'uebernahmedatum' => date('c'),
+							'benotungsdatum' => $antragLv->insertamum,
+							'insertamum' => date('c'),
+							'bemerkung'=>$antragLv->anmerkung,
+							'insertvon'=>getAuthUID()
+						]);
+					}
+					if(isError($result))
+					{
+						$errormsg[] = getError($result);
+					}
+				}
+			}
+		}
+
+		if($errormsg)
+			$return = false;
+		else
+			$return = true;
+
+		$this->load->view('lehre/Antrag/Wiederholung/moveLvs.rdf.php', [
+			'return' => $return,
+			'errormsg' => $errormsg
+		]);
+	}
+}

application/controllers/api/frontend/v1/Filter.php

@@ -0,0 +1,231 @@
+<?php
+/**
+ * Copyright (C) 2024 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');
+
+/**
+ * This controller operates between (interface) the JS (GUI) and the FilterCmptLib (back-end)
+ * Provides data to the ajax get calls about the filter component
+ * Listens to ajax post calls to change the filter data
+ * This controller works with JSON calls on the HTTP GET or POST and the output is always JSON
+ */
+class Filter extends FHCAPI_Controller
+{
+	const FILTER_UNIQUE_ID = 'filterUniqueId'; // Name of the filter cmpt unique id (mandatory)
+	const FILTER_TYPE = 'filterType'; // The filter type (PHP filter definition) used (mandatory)
+	const FILTER_ID = 'filterId'; // The id of the used filter (optional)
+
+	/**
+	 * Calls the parent's constructor and loads the FilterCmptLib
+	 */
+	public function __construct()
+	{
+		// NOTE: FilterCmpt has its own permissions checks
+		parent::__construct([
+			'getFilter' => self::PERM_LOGGED,
+			'removeFilterField' => self::PERM_LOGGED,
+			'addFilterField' => self::PERM_LOGGED,
+			'applyFilterFields' => self::PERM_LOGGED,
+			'removeCustomFilter' => self::PERM_LOGGED,
+			'saveCustomFilter' => self::PERM_LOGGED,
+			'reloadDataset' => self::PERM_LOGGED
+		]);
+
+		// Loads the FiltersModel
+		$this->load->model('system/Filters_model', 'FiltersModel');
+
+		// Loads the FilterCmptLib with HTTP GET/POST parameters
+		$this->_startFilterCmptLib();
+	}
+
+	//------------------------------------------------------------------------------------------------------------------
+	// Public methods
+
+	/**
+	 * Retrieves data about the current filter from the session and will be written on the output in JSON format
+	 */
+	public function getFilter()
+	{
+		if (!$this->form_validation->run())
+			$this->terminateWithValidationErrors($this->form_validation->error_array());
+
+		$session = $this->filtercmptlib->getSession();
+		if (is_object($session)) {
+			// If stdClass it is an retval object
+			$session = $this->getDataOrTerminateWithError($session);
+		}
+		$this->terminateWithSuccess($session);
+	}
+
+	/**
+	 * Remove an applied filter (SQL where condition) from the current filter
+	 */
+	public function removeFilterField()
+	{
+		$this->form_validation->set_rules('filterField', 'filterField', 'required');
+
+		if (!$this->form_validation->run())
+			$this->terminateWithValidationErrors($this->form_validation->error_array());
+
+		$result = $this->filtercmptlib->removeFilterField($this->input->post('filterField'));
+
+		if (!$result)
+			$this->terminateWithError('Error occurred', self::ERROR_TYPE_GENERAL);
+
+		$this->terminateWithSuccess('Field removed');
+	}
+
+	/**
+	 * Add a filter (SQL where clause) to be applied to the current filter
+	 */
+	public function addFilterField()
+	{
+		$this->form_validation->set_rules('filterField', 'filterField', 'required');
+
+		if (!$this->form_validation->run())
+			$this->terminateWithValidationErrors($this->form_validation->error_array());
+
+		$result = $this->filtercmptlib->addFilterField($this->input->post('filterField'));
+
+		if (!$result)
+			$this->terminateWithError('Error occurred', self::ERROR_TYPE_GENERAL);
+
+		$this->terminateWithSuccess('Field added');
+	}
+
+	/**
+	 * Apply the filter changes
+	 */
+	public function applyFilterFields()
+	{
+		$this->form_validation->set_rules('filterFields', 'filterFields', 'required');
+
+		if (!$this->form_validation->run())
+			$this->terminateWithValidationErrors($this->form_validation->error_array());
+
+		$result = $this->filtercmptlib->applyFilterFields($this->input->post('filterFields'));
+
+		if (!$result)
+			$this->terminateWithError('Error occurred', self::ERROR_TYPE_GENERAL);
+
+		$this->terminateWithSuccess('Applied');
+	}
+
+	/**
+	 * Save the current filter as a custom filter for this user with the given description
+	 */
+	public function saveCustomFilter()
+	{
+		$this->form_validation->set_rules('customFilterName', 'customFilterName', 'required');
+
+		if (!$this->form_validation->run())
+			$this->terminateWithValidationErrors($this->form_validation->error_array());
+
+		$result = $this->filtercmptlib->saveCustomFilter($this->input->post('customFilterName'));
+
+		if (!$result)
+			$this->terminateWithError('Error occurred', self::ERROR_TYPE_GENERAL);
+
+		$this->terminateWithSuccess('Saved');
+	}
+
+	/**
+	 * Remove a custom filter by its filterId
+	 */
+	public function removeCustomFilter()
+	{
+		$this->form_validation->set_rules('filterId', 'filterId', 'required');
+
+		if (!$this->form_validation->run())
+			$this->terminateWithValidationErrors($this->form_validation->error_array());
+
+		$result = $this->filtercmptlib->removeCustomFilter($this->input->post('filterId'));
+
+		if (!$result)
+			$this->terminateWithError('Error occurred', self::ERROR_TYPE_GENERAL);
+
+		$this->terminateWithSuccess('Removed');
+	}
+
+	/**
+	 * Reloads the dataset
+	 */
+	public function reloadDataset()
+	{
+		if (!$this->form_validation->run())
+			$this->terminateWithValidationErrors($this->form_validation->error_array());
+
+		$this->filtercmptlib->reloadDataset();
+
+		$this->terminateWithSuccess('Success');
+	}
+
+	//------------------------------------------------------------------------------------------------------------------
+	// Private methods
+
+	/**
+	 * Loads the FilterCmptLib with the FILTER_UNIQUE_ID parameter
+	 * If the parameter FILTER_UNIQUE_ID is not given then the execution of the controller is terminated and
+	 * an error message is printed
+	 */
+	private function _startFilterCmptLib()
+	{
+		$filterUniqueId = null;
+		$filterType = null;
+		$filterId = null;
+
+		$validations = [
+			[
+				'field' => self::FILTER_UNIQUE_ID,
+				'label' => self::FILTER_UNIQUE_ID,
+				'rules' => 'required'
+			],
+			[
+				'field' => self::FILTER_TYPE,
+				'label' => self::FILTER_TYPE,
+				'rules' => 'required'
+			],
+		];
+
+		$this->load->library('form_validation');
+
+		if ($this->input->method() == 'get')
+			$this->form_validation->set_data($this->input->get());
+		$this->form_validation->set_rules($validations);
+
+		if ($this->form_validation->run()) {
+			$filterUniqueId = $this->input->post_get(self::FILTER_UNIQUE_ID);
+			$filterType = $this->input->post_get(self::FILTER_TYPE);
+			$filterId = $this->input->post_get(self::FILTER_ID);
+
+			// Loads the FilterCmptLib that contains all the used logic
+			$this->load->library(
+				'FilterCmptLib',
+				array(
+					'filterUniqueId' => $filterUniqueId,
+					'filterType' => $filterType,
+					'filterId' => $filterId
+				)
+			);
+
+			// Start the component
+			$this->filtercmptlib->start();
+		}
+	}
+}
+

application/controllers/api/frontend/v1/Navigation.php

@@ -0,0 +1,101 @@
+<?php
+/**
+ * Copyright (C) 2024 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');
+
+/**
+ * This controller operates between (interface) the JS (GUI) and the NavigationLib (back-end)
+ * Provides data to the ajax get calls about the filter
+ * This controller works with JSON calls on the HTTP GET or POST and the output is always JSON
+ */
+class Navigation extends FHCAPI_Controller
+{
+	const NAVIGATION_PAGE_PARAM = 'navigation_page'; // Navigation page parameter name
+
+	/**
+	 * Loads the NavigationLib where the used logic lies
+	 */
+	public function __construct()
+    {
+        parent::__construct([
+        	'menu' => self::PERM_LOGGED,
+        	'header' => self::PERM_LOGGED
+        ]);
+
+		$this->_loadNavigationLib(); // Loads the NavigationLib with parameters
+	}
+
+	//------------------------------------------------------------------------------------------------------------------
+	// Public methods
+
+	/**
+	 * This function creates the left Menu for each Page
+	 * @param NAVIGATION_PAGE_PARAM GET Parameter witch holds the currently called Page
+	 * @return JSON object with the Menu Entries
+	 */
+	public function menu()
+	{
+		$menuArray = $this->navigationlib->getMenuArray($this->input->get(self::NAVIGATION_PAGE_PARAM));
+
+		$this->terminateWithSuccess($menuArray);
+	}
+
+	/**
+	 * This function creates the Top Menu for each Page
+	 * @param NAVIGATION_PAGE_PARAM GET Parameter witch holds the currently called Page
+	 * @return JSON object with the Menu Entries
+	 */
+	public function header()
+	{
+		$headerArray = $this->navigationlib->getHeaderArray($this->input->get(self::NAVIGATION_PAGE_PARAM));
+
+		$this->terminateWithSuccess($headerArray);
+	}
+
+	//------------------------------------------------------------------------------------------------------------------
+	// Private methods
+
+	/**
+	 * Loads the NavigationLib with the NAVIGATION_PAGE_PARAM parameter
+	 * If the parameter NAVIGATION_PAGE_PARAM is not given then the execution of the controller is terminated and
+	 * an error message is printed
+	 */
+	private function _loadNavigationLib()
+	{
+		// If the parameter NAVIGATION_PAGE_PARAM is present in the HTTP GET or POST
+		if (isset($_GET[self::NAVIGATION_PAGE_PARAM]) || isset($_POST[self::NAVIGATION_PAGE_PARAM]))
+		{
+			// If it is present in the HTTP GET
+			if (isset($_GET[self::NAVIGATION_PAGE_PARAM]))
+			{
+				$navigationPage = $this->input->get(self::NAVIGATION_PAGE_PARAM); // is retrieved from the HTTP GET
+			}
+			elseif (isset($_POST[self::NAVIGATION_PAGE_PARAM])) // Else if it is present in the HTTP POST
+			{
+				$navigationPage = $this->input->post(self::NAVIGATION_PAGE_PARAM); // is retrieved from the HTTP POST
+			}
+
+			// Loads the NavigationLib that contains all the used logic
+			$this->load->library('NavigationLib', array(self::NAVIGATION_PAGE_PARAM => $navigationPage));
+		}
+		else // Otherwise an error will be written in the output
+		{
+			show_error('Parameter "' . self::NAVIGATION_PAGE_PARAM . '" not provided!');
+		}
+	}
+}

application/controllers/api/frontend/v1/Phrasen.php

@@ -0,0 +1,46 @@
+<?php
+/**
+ * Copyright (C) 2024 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');
+
+/**
+ * This controller operates between (interface) the JS (GUI) and the PhrasesLib (back-end)
+ * Provides data to the ajax get calls about the Phrasen plugin
+ * This controller works with JSON calls on the HTTP GET and the output is always JSON
+ */
+class Phrasen extends FHCAPI_Controller
+{
+	public function __construct()
+	{
+		parent::__construct([
+			'loadModule' => self::PERM_ANONYMOUS
+		]);
+	}
+	
+	//------------------------------------------------------------------------------------------------------------------
+	// Public methods
+
+	/**
+	 * @param string $module
+	 */
+	public function loadModule($module)
+	{
+		$this->load->library('PhrasesLib', [$module], 'pj');
+		$this->terminateWithSuccess(json_decode($this->pj->getJSON()));
+	}
+}

application/controllers/api/frontend/v1/Searchbar.php

@@ -0,0 +1,69 @@
+<?php
+/**
+ * Copyright (C) 2024 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');
+
+/**
+ * This controller operates between (interface) the JS (GUI) and the SearchBarLib (back-end)
+ * Provides data to the ajax get calls about the searchbar component
+ * This controller works with JSON calls on the HTTP GET and the output is always JSON
+ */
+class Searchbar extends FHCAPI_Controller
+{
+	const SEARCHSTR_PARAM = 'searchstr';
+	const TYPES_PARAM = 'types';
+
+	/**
+	 * Object initialization
+	 */
+	public function __construct()
+	{
+		// NOTE(chris): additional permission checks will be done in SearchBarLib
+		parent::__construct([
+			'search' => self::PERM_LOGGED
+		]);
+
+		// Load the library SearchBarLib
+		$this->load->library('SearchBarLib');
+	}
+
+	//------------------------------------------------------------------------------------------------------------------
+	// Public methods
+
+	/**
+	 * Gets a JSON body via HTTP POST and provides the parameters
+	 */
+	public function search()
+	{
+		$this->load->library('form_validation');
+
+		// Checks if the searchstr and the types parameters are in the POSTed JSON
+		$this->form_validation->set_rules(self::SEARCHSTR_PARAM, null, 'required');
+		$this->form_validation->set_rules(self::TYPES_PARAM . '[]', null, 'required');
+
+		if (!$this->form_validation->run())
+			$this->terminateWithError(SearchBarLib::ERROR_WRONG_JSON, self::ERROR_TYPE_GENERAL);
+
+		// Convert to json the result from searchbarlib->search
+		$result = $this->searchbarlib->search($this->input->post(self::SEARCHSTR_PARAM), $this->input->post(self::TYPES_PARAM));
+		if (property_exists($result, 'error'))
+			$this->terminateWithError(getError($result), self::ERROR_TYPE_GENERAL);
+		$this->terminateWithSuccess($result);
+	}
+}
+

application/controllers/api/frontend/v1/studstatus/Abmeldung.php

@@ -0,0 +1,187 @@
+<?php
+/**
+ * Copyright (C) 2024 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 \REST_Controller as REST_Controller;
+use \Studierendenantrag_model as Studierendenantrag_model;
+
+/**
+ * This controller operates between (interface) the JS (GUI) and the AntragLib (back-end)
+ * This controller works with JSON calls on the HTTP GET or POST and the output is always JSON
+ */
+class Abmeldung extends FHCAPI_Controller
+{
+
+	/**
+	 * Calls the parent's constructor and loads the AntragLib
+	 */
+	public function __construct()
+	{
+		parent::__construct([
+			'getDetailsForNewAntrag' => self::PERM_LOGGED,
+			'getDetailsForAntrag' => self::PERM_LOGGED,
+			'createAntrag' => self::PERM_LOGGED,
+			'cancelAntrag' => self::PERM_LOGGED
+		]);
+
+		// Libraries
+		$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->terminateWithError('Forbidden', self::ERROR_TYPE_AUTH, REST_Controller::HTTP_FORBIDDEN);
+
+		$result = $this->antraglib->getPrestudentAbmeldeBerechtigt($prestudent_id);
+		$result = $this->getDataOrTerminateWithError($result);
+		
+		if (!$result) {
+			$this->terminateWithError(
+				$this->p->t('studierendenantrag', 'error_no_student'),
+				self::ERROR_TYPE_AUTH,
+				REST_Controller::HTTP_FORBIDDEN
+			);
+		} elseif ($result == -3) {
+			$this->terminateWithError(
+				$this->p->t('studierendenantrag', 'error_stg_blacklist'),
+				self::ERROR_TYPE_AUTH,
+				REST_Controller::HTTP_FORBIDDEN
+			);
+		} elseif ($result == -1) {
+			$result = $this->antraglib->getDetailsForLastAntrag(
+                $prestudent_id,
+                [
+                    Studierendenantrag_model::TYP_ABMELDUNG,
+                    Studierendenantrag_model::TYP_ABMELDUNG_STGL
+                ]
+            );
+
+			$data = $this->getDataOrTerminateWithError($result);
+			
+			$data->canCancel = (
+				$data->status == Studierendenantragstatus_model::STATUS_CREATED &&
+				$this->antraglib->isEntitledToCancelAntrag($data->studierendenantrag_id)
+			);
+
+			$this->terminateWithSuccess($data);
+		}
+
+		$result = $this->antraglib->getDetailsForNewAntrag($prestudent_id);
+
+		$data = $this->getDataOrTerminateWithError($result);
+
+		$this->terminateWithSuccess($data);
+	}
+
+	public function getDetailsForAntrag($studierendenantrag_id)
+	{
+		if (!$this->antraglib->isEntitledToShowAntrag($studierendenantrag_id))
+			return show_404();
+
+		$result = $this->antraglib->getDetailsForAntrag($studierendenantrag_id);
+		
+		$data = $this->getDataOrTerminateWithError($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->terminateWithSuccess($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');
+
+		if (!$this->form_validation->run())
+			$this->terminateWithValidationErrors($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);
+		$result = $this->getDataOrTerminateWithError($result);
+		if (!$result)
+			$this->terminateWithError($this->p->t('studierendenantrag', 'error_no_student'), self::ERROR_TYPE_GENERAL);
+		elseif ($result == -3)
+			$this->terminateWithError($this->p->t('studierendenantrag', 'error_stg_blacklist'), self::ERROR_TYPE_GENERAL);
+		elseif ($result < 0)
+			$this->terminateWithError($this->p->t('studierendenantrag', 'error_antrag_exists'), self::ERROR_TYPE_GENERAL);
+
+		$result = $this->antraglib->createAbmeldung($prestudent_id, $studiensemester, getAuthUID(), $grund);
+		$data = $this->getDataOrTerminateWithError($result);
+
+		$result = $this->antraglib->getDetailsForAntrag($data);
+		if (!hasData($result))
+			return $this->terminateWithSuccess(true);
+
+		$data = getData($result);
+		$data->canCancel = (boolean)$this->antraglib->isEntitledToCancelAntrag($data->studierendenantrag_id);
+
+		$this->terminateWithSuccess($data);
+	}
+
+	public function cancelAntrag()
+	{
+		$this->load->library('form_validation');
+
+		$this->form_validation->set_rules('antrag_id', 'Antrag ID', 'required');
+
+		if (!$this->form_validation->run())
+			$this->terminateWithValidationErrors($this->form_validation->error_array());
+
+		$antrag_id = $this->input->post('antrag_id');
+
+		if (!$this->antraglib->isEntitledToCancelAntrag($antrag_id))
+			$this->terminateWithError('Forbidden', self::ERROR_TYPE_AUTH, REST_Controller::HTTP_FORBIDDEN);
+
+		$result = $this->antraglib->cancelAntrag($antrag_id, getAuthUID());
+		$this->getDataOrTerminateWithError($result);
+
+		$result = $this->antraglib->getDetailsForAntrag($antrag_id);
+		if (!hasData($result))
+			$this->terminateWithSuccess($antrag_id);
+		
+		$data = getData($result);
+		
+		$this->terminateWithSuccess($data);
+	}
+}

application/controllers/api/frontend/v1/studstatus/Leitung.php

@@ -0,0 +1,428 @@
+<?php
+/**
+ * Copyright (C) 2024 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;
+use \Studierendenantrag_model as Studierendenantrag_model;
+
+/**
+ * This controller operates between (interface) the JS (GUI) and the AntragLib (back-end)
+ * This controller works with JSON calls on the HTTP GET or POST and the output is always JSON
+ */
+class Leitung extends FHCAPI_Controller
+{
+
+	/**
+	 * Calls the parent's constructor and loads the AntragLib
+	 */
+	public function __construct()
+	{
+		parent::__construct([
+			'getActiveStgs' => ['student/antragfreigabe:r', 'student/studierendenantrag:r'],
+			'getAntraege' => ['student/antragfreigabe:r', 'student/studierendenantrag:r'],
+			'getHistory' => ['student/antragfreigabe:r', 'student/studierendenantrag:r'],
+			'getPrestudents' => 'student/studierendenantrag:w',
+			'approveAntrag' => 'student/antragfreigabe:w',
+			'rejectAntrag' => 'student/antragfreigabe:w',
+			'reopenAntrag' => 'student/studierendenantrag:w',
+			'pauseAntrag' => ['student/antragfreigabe:w', 'student/studierendenantrag:w'],
+			'unpauseAntrag' => ['student/antragfreigabe:w', 'student/studierendenantrag:w'],
+			'objectAntrag' => ['student/antragfreigabe:w', 'student/studierendenantrag:w'],
+			'approveObjection' => ['student/antragfreigabe:w', 'student/studierendenantrag:w'],
+			'denyObjection' => ['student/antragfreigabe:w', 'student/studierendenantrag:w']
+		]);
+
+		// Libraries
+		$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);
+		$data = $this->getDataOrTerminateWithError($result);
+
+		$this->terminateWithSuccess($data);
+	}
+
+	public function getAntraege($studiengang = null, $extra = null)
+	{
+		if ($studiengang && $studiengang == 'todo') {
+			$studiengang = $extra;
+			$extra = true;
+		} else {
+			$extra = false;
+		}
+
+		$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));
+
+		if ($studiengang) {
+			if (!in_array($studiengang, $studiengaenge))
+				$this->terminateWithError(
+					'Forbidden',
+					self::ERROR_TYPE_AUTH,
+					REST_Controller::HTTP_FORBIDDEN
+				);
+			$studiengaenge = [$studiengang];
+		}
+
+		$antraege = [];
+		if ($studiengaenge) {
+			$result = $extra
+				? $this->StudierendenantragModel->loadActiveForStudiengaenge($studiengaenge)
+				: $this->StudierendenantragModel->loadForStudiengaenge($studiengaenge);
+
+			$antraege = $this->getDataOrTerminateWithError($result);
+		}
+
+		$this->terminateWithSuccess($antraege ?: []);
+	}
+
+	public function getHistory($studierendenantrag_id)
+	{
+		if (!$this->antraglib->isEntitledToSeeHistoryForAntrag($studierendenantrag_id))
+			$this->terminateWithError(
+				'Forbidden',
+				self::ERROR_TYPE_AUTH,
+				REST_Controller::HTTP_FORBIDDEN
+			);
+
+		$result = $this->antraglib->getAntragHistory($studierendenantrag_id);
+		$data = $this->getDataOrTerminateWithError($result);
+		
+		$this->terminateWithSuccess($data ?: []);
+	}
+
+	public function getPrestudents()
+	{
+		$query = $this->input->post('query');
+
+		$studiengaenge = $this->permissionlib->getSTG_isEntitledFor('student/studierendenantrag');
+
+		$result = $this->antraglib->getAktivePrestudentenInStgs($studiengaenge, $query);
+		$result = $this->getDataOrTerminateWithError($result);
+
+		return $this->terminateWithSuccess($result ?: []);
+	}
+
+	public function approveAntrag()
+	{
+		$this->load->library('form_validation');
+
+		$this->form_validation->set_rules(
+			'studierendenantrag_id',
+			'Studierenden Antrag',
+			[
+				'required',
+				['isEntitledToApproveAntrag', [$this->antraglib, 'isEntitledToApproveAntrag']],
+			],
+			[
+				'isEntitledToApproveAntrag' => $this->p->t('studierendenantrag', 'error_no_right')
+			]
+		);
+		$this->form_validation->set_rules(
+			'typ',
+			'Typ',
+			'required|in_list[' . implode(',', [
+				Studierendenantrag_model::TYP_ABMELDUNG,
+				Studierendenantrag_model::TYP_ABMELDUNG_STGL,
+				Studierendenantrag_model::TYP_UNTERBRECHUNG,
+				Studierendenantrag_model::TYP_WIEDERHOLUNG
+			]) . ']'
+		);
+
+		if (!$this->form_validation->run())
+			$this->terminateWithValidationErrors($this->form_validation->error_array());
+
+		$studierendenantrag_id = $this->input->post('studierendenantrag_id');
+		switch ($this->input->post('typ')) {
+			case Studierendenantrag_model::TYP_ABMELDUNG:
+			case Studierendenantrag_model::TYP_ABMELDUNG_STGL:
+				$result = $this->antraglib->approveAbmeldung([$studierendenantrag_id], getAuthUID());
+				break;
+			case Studierendenantrag_model::TYP_UNTERBRECHUNG:
+				$result = $this->antraglib->approveUnterbrechung([$studierendenantrag_id], getAuthUID());
+				break;
+			case Studierendenantrag_model::TYP_WIEDERHOLUNG:
+				$result = $this->antraglib->approveWiederholung($studierendenantrag_id, getAuthUID());
+				break;
+		}
+		$this->getDataOrTerminateWithError($result);
+
+		return $this->terminateWithSuccess($studierendenantrag_id);
+	}
+
+	public function rejectAntrag()
+	{
+		$this->load->library('form_validation');
+
+		$this->form_validation->set_rules(
+			'studierendenantrag_id',
+			'Studierenden Antrag',
+			[
+				'required',
+				['isEntitledToRejectAntrag', [$this->antraglib, 'isEntitledToRejectAntrag']],
+			],
+			[
+				'isEntitledToRejectAntrag' => $this->p->t('studierendenantrag', 'error_no_right')
+			]
+		);
+		$this->form_validation->set_rules('grund', 'Grund', 'required');
+		$this->form_validation->set_rules(
+			'typ',
+			'Typ',
+			'required|in_list[' . implode(',', [
+				Studierendenantrag_model::TYP_UNTERBRECHUNG
+			]) . ']'
+		);
+
+		if (!$this->form_validation->run())
+			$this->terminateWithValidationErrors($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);
+		$this->getDataOrTerminateWithError($result);
+
+		return $this->terminateWithSuccess($studierendenantrag_id);
+	}
+
+	public function reopenAntrag()
+	{
+		$this->load->library('form_validation');
+
+		$this->form_validation->set_rules(
+			'studierendenantrag_id',
+			'Studierenden Antrag',
+			[
+				'required',
+				['isEntitledToReopenAntrag', [$this->antraglib, 'isEntitledToReopenAntrag']],
+			],
+			[
+				'isEntitledToReopenAntrag' => $this->p->t('studierendenantrag', 'error_no_right')
+			]
+		);
+		$this->form_validation->set_rules(
+			'typ',
+			'Typ',
+			'required|in_list[' . implode(',', [
+				Studierendenantrag_model::TYP_WIEDERHOLUNG
+			]) . ']'
+		);
+
+		if (!$this->form_validation->run())
+			$this->terminateWithValidationErrors($this->form_validation->error_array());
+
+		$studierendenantrag_id = $this->input->post('studierendenantrag_id');
+
+		$result = $this->antraglib->reopenWiederholung($studierendenantrag_id, getAuthUID());
+		$this->getDataOrTerminateWithError($result);
+
+		return $this->terminateWithSuccess($studierendenantrag_id);
+	}
+
+	public function pauseAntrag()
+	{
+		$this->load->library('form_validation');
+
+		$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())
+			$this->terminateWithValidationErrors($this->form_validation->error_array());
+
+		$studierendenantrag_id = $this->input->post('studierendenantrag_id');
+
+		$result = $this->antraglib->pauseAntrag($studierendenantrag_id, getAuthUID());
+		$this->getDataOrTerminateWithError($result);
+
+		return $this->terminateWithSuccess($studierendenantrag_id);
+	}
+
+	public function unpauseAntrag()
+	{
+		$this->load->library('form_validation');
+
+		$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())
+			$this->terminateWithValidationErrors($this->form_validation->error_array());
+
+		$studierendenantrag_id = $this->input->post('studierendenantrag_id');
+
+		$result = $this->antraglib->unpauseAntrag($studierendenantrag_id, getAuthUID());
+		$this->getDataOrTerminateWithError($result);
+
+		return $this->terminateWithSuccess($studierendenantrag_id);
+	}
+
+	public function objectAntrag()
+	{
+		$this->load->library('form_validation');
+
+		$this->form_validation->set_rules(
+			'studierendenantrag_id',
+			'Studierenden Antrag',
+			[
+				'required',
+				['isEntitledToObjectAntrag', [$this->antraglib, 'isEntitledToObjectAntrag']],
+				['canBeObjected', function ($a) {
+					return $this->antraglib->hasType($a, Studierendenantrag_model::TYP_ABMELDUNG_STGL);
+				}]
+			],
+			[
+				'isEntitledToObjectAntrag' => $this->p->t('studierendenantrag', 'error_no_right'),
+				'canBeObjected' => $this->p->t(
+					'studierendenantrag',
+					'error_no_objection'
+				)
+			]
+		);
+
+		if (!$this->form_validation->run())
+			$this->terminateWithValidationErrors($this->form_validation->error_array());
+
+		$studierendenantrag_id = $this->input->post('studierendenantrag_id');
+
+		$result = $this->antraglib->objectAbmeldung($studierendenantrag_id, getAuthUID());
+		$this->getDataOrTerminateWithError($result);
+
+		return $this->terminateWithSuccess($studierendenantrag_id);
+	}
+
+	public function approveObjection()
+	{
+		$this->load->library('form_validation');
+
+		$this->form_validation->set_rules(
+			'studierendenantrag_id',
+			'Studierenden Antrag',
+			[
+				'required',
+				['isEntitledToObjectAntrag', [$this->antraglib, 'isEntitledToObjectAntrag']],
+				['isObjected', function ($a) {
+					return $this->antraglib->hasStatus($a, Studierendenantragstatus_model::STATUS_OBJECTED);
+				}]
+			],
+			[
+				'isEntitledToObjectAntrag' => $this->p->t('studierendenantrag', 'error_no_right'),
+				'isObjected' => $this->p->t(
+					'studierendenantrag',
+					'error_not_objected'
+				)
+			]
+		);
+
+		if (!$this->form_validation->run())
+			$this->terminateWithValidationErrors($this->form_validation->error_array());
+
+		$studierendenantrag_id = $this->input->post('studierendenantrag_id');
+		
+		$result = $this->antraglib->cancelAntrag($studierendenantrag_id, getAuthUID());
+		$this->getDataOrTerminateWithError($result);
+
+		return $this->terminateWithSuccess($studierendenantrag_id);
+	}
+
+	public function denyObjection()
+	{
+		$this->load->library('form_validation');
+
+		$this->form_validation->set_rules(
+			'studierendenantrag_id',
+			'Studierenden Antrag',
+			[
+				'required',
+				['isEntitledToObjectAntrag', [$this->antraglib, 'isEntitledToObjectAntrag']],
+				['isObjected', function ($a) {
+					return $this->antraglib->hasStatus($a, Studierendenantragstatus_model::STATUS_OBJECTED);
+				}]
+			],
+			[
+				'isEntitledToObjectAntrag' => $this->p->t('studierendenantrag', 'error_no_right'),
+				'isObjected' => $this->p->t(
+					'studierendenantrag',
+					'error_not_objected'
+				)
+			]
+		);
+
+		if (!$this->form_validation->run())
+			$this->terminateWithValidationErrors($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);
+		$this->getDataOrTerminateWithError($result);
+
+		return $this->terminateWithSuccess($studierendenantrag_id);
+	}
+}

application/controllers/api/frontend/v1/studstatus/Unterbrechung.php

@@ -1,4 +1,20 @@
 <?php
+/**
+ * Copyright (C) 2024 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');
 
@@ -6,23 +22,28 @@ use \Studierendenantrag_model as Studierendenantrag_model;
 use \DateTime as DateTime;
 
 /**
- *
+ * This controller operates between (interface) the JS (GUI) and the AntragLib (back-end)
+ * This controller works with JSON calls on the HTTP GET or POST and the output is always JSON
  */
-class Unterbrechung extends FHC_Controller
+class Unterbrechung extends FHCAPI_Controller
 {
 
 	/**
-	 * Calls the parent's constructor and loads the FilterCmptLib
+	 * Calls the parent's constructor and loads the AntragLib
 	 */
 	public function __construct()
 	{
-		parent::__construct();
+		parent::__construct([
+			'getDetailsForNewAntrag' => self::PERM_LOGGED,
+			'getDetailsForAntrag' => self::PERM_LOGGED,
+			'createAntrag' => self::PERM_LOGGED,
+			'cancelAntrag' => self::PERM_LOGGED
+		]);
 
 		// Configs
 		$this->load->config('studierendenantrag');
 
 		// Libraries
-		$this->load->library('AuthLib');
 		$this->load->library('AntragLib');
 
 		// Load language phrases
@@ -38,74 +59,62 @@ class Unterbrechung extends FHC_Controller
 
 	public function getDetailsForNewAntrag($prestudent_id)
 	{
-		if (!$this->antraglib->isEntitledToCreateAntragFor($prestudent_id, false)) {
+		if (!$this->antraglib->isEntitledToCreateAntragFor($prestudent_id, false))
-			$this->output->set_status_header(403);
+			$this->terminateWithError('Forbidden', self::ERROR_TYPE_AUTH, REST_Controller::HTTP_FORBIDDEN);
-			return $this->outputJsonError('Forbidden');
+
-		}
 		$result = $this->antraglib->getPrestudentUnterbrechungsBerechtigt($prestudent_id);
-		if (isError($result)) {
+		$result = $this->getDataOrTerminateWithError($result);
-			$this->output->set_status_header(500);
+
-			return $this->outputJsonError(getError($result));
-		}
-		$result = $result->retval;
 		if (!$result) {
-			$this->output->set_status_header(403);
+			$this->terminateWithError(
-			return $this->outputJsonError($this->p->t('studierendenantrag', 'error_no_student'));
+				$this->p->t('studierendenantrag', 'error_no_student'),
-		}
+				self::ERROR_TYPE_AUTH,
-		elseif ($result == -1)
+				REST_Controller::HTTP_FORBIDDEN
-		{
+			);
+		} elseif ($result == -1) {
 			$result = $this->antraglib->getDetailsForLastAntrag($prestudent_id, Studierendenantrag_model::TYP_UNTERBRECHUNG);
-			if (isError($result)) {
+			
-				return $this->outputJsonError(getError($result));
+			$data = $this->getDataOrTerminateWithError($result);
-			}
 
-			return $this->outputJsonSuccess(getData($result));
+			return $this->terminateWithSuccess($data);
-		}
+		} elseif ($result == -2) {
-		elseif ($result == -2)
-		{
 			$result = $this->antraglib->getDetailsForLastAntrag($prestudent_id);
-			if (isError($result)) {
-				return $this->outputJsonError(getError($result));
-			}
 
-			$result = getData($result);
+			$data = $this->getDataOrTerminateWithError($result);
-			$this->output->set_status_header(400);
+
-			return $this->outputJsonError($this->p->t('studierendenantrag', 'error_antrag_pending', [
+			return $this->terminateWithError($this->p->t('studierendenantrag', 'error_antrag_pending', [
                 'typ' => $this->p->t('studierendenantrag', 'antrag_typ_' . $result->typ)
             ]));
-		}
+		} elseif ($result == -3) {
-		elseif ($result == -3)
+			$this->terminateWithError(
-		{
+				$this->p->t('studierendenantrag', 'error_stg_blacklist'),
-			$this->output->set_status_header(403);
+				self::ERROR_TYPE_AUTH,
-			return $this->outputJsonError($this->p->t('studierendenantrag', 'error_stg_blacklist'));
+				REST_Controller::HTTP_FORBIDDEN
-		}
+			);
-		$result = $this->antraglib->getDetailsForNewAntrag($prestudent_id);
-		if (isError($result)) {
-			return $this->outputJsonError(getError($result));
 		}
 
-		$data = getData($result);
+		$result = $this->antraglib->getDetailsForNewAntrag($prestudent_id);
+
+		$data = $this->getDataOrTerminateWithError($result);
 
 		$data->studiensemester = $this->antraglib->getSemesterForUnterbrechung($prestudent_id, null);
 
-		$this->outputJsonSuccess($data);
+		$this->terminateWithSuccess($data);
 	}
 
 	public function getDetailsForAntrag($studierendenantrag_id)
 	{
-		if (!$this->antraglib->isEntitledToShowAntrag($studierendenantrag_id))	return show_404();
+		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);
+		$data = $this->getDataOrTerminateWithError($result);
 
 		if ($data->typ !== Studierendenantrag_model::TYP_UNTERBRECHUNG)
 			return show_404();
 
-		$this->outputJsonSuccess($data);
+		$this->terminateWithSuccess($data);
 	}
 
 	public function createAntrag()
@@ -125,9 +134,8 @@ class Unterbrechung extends FHC_Controller
 			]
 		);
 
-		if ($this->form_validation->run() == false)
+		if (!$this->form_validation->run()) {
-		{
+			$this->terminateWithValidationErrors($this->form_validation->error_array());
-			return $this->outputJsonError($this->form_validation->error_array());
 		}
 
 		$grund = $this->input->post('grund');
@@ -137,25 +145,17 @@ class Unterbrechung extends FHC_Controller
 		$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))
+		$result = $this->getDataOrTerminateWithError($result);
-		{
+		
+		if (!$result)
+			$this->terminateWithError($this->p->t('studierendenantrag', 'error_no_student'), self::ERROR_TYPE_GENERAL);
+		elseif ($result == -3)
+			$this->terminateWithError($this->p->t('studierendenantrag', 'error_stg_blacklist'), self::ERROR_TYPE_GENERAL);
+		elseif ($result < 0)
+			$this->terminateWithError($this->p->t('studierendenantrag', 'error_antrag_exists'), self::ERROR_TYPE_GENERAL);
+		
+		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');
@@ -167,53 +167,46 @@ class Unterbrechung extends FHC_Controller
 
 			$allowed_filetypes = $this->config->item('unterbrechung_dms_filetypes') ?: ['*'];
 			$result = $this->dmslib->upload($dms, 'attachment', $allowed_filetypes);
-			if(isError($result))
+
-			{
+			$data = $this->getDataOrTerminateWithError($result);
-				return $this->outputJsonError(['db' => getError($result)]);
+			
-			}
+			$dms_id = $data['dms_id'];
-			$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);
+		$antragId = $this->getDataOrTerminateWithError($result);
+		
 		$result = $this->antraglib->getDetailsForAntrag($antragId);
 
-		if(!hasData($result))
+		if (!hasData($result))
-			return $this->outputJsonSuccess($antragId);
+			$this->terminateWithSuccess($antragId);
-		$this->outputJsonSuccess(getData($result));
+
+		$this->terminateWithSuccess(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)
+		if (!$this->form_validation->run()) {
-		{
+			$this->terminateWithValidationErrors($this->form_validation->error_array());
-			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))
+
-		{
+		$this->getDataOrTerminateWithError($result);
-			return $this->outputJsonError(['db' => getError($result)]);
-		}
 
 		$result = $this->antraglib->getDetailsForAntrag($antrag_id);
 
 		if (!hasData($result))
-			return $this->outputJsonSuccess($antrag_id);
+			return $this->terminateWithSuccess($antrag_id);
-		$this->outputJsonSuccess(getData($result));
+	
+		$this->terminateWithSuccess(getData($result));
 	}
 
 	public function isValidDate($date)

application/controllers/api/frontend/v1/studstatus/Wiederholung.php

@@ -0,0 +1,258 @@
+<?php
+/**
+ * Copyright (C) 2024 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 \REST_Controller as REST_Controller;
+use \Studierendenantragstatus_model as Studierendenantragstatus_model;
+
+/**
+ * This controller operates between (interface) the JS (GUI) and the AntragLib (back-end)
+ * This controller works with JSON calls on the HTTP GET or POST and the output is always JSON
+ */
+class Wiederholung extends FHCAPI_Controller
+{
+
+	/**
+	 * Calls the parent's constructor and loads the FilterCmptLib
+	 */
+	public function __construct()
+	{
+		parent::__construct([
+			'getDetailsForNewAntrag' => self::PERM_LOGGED,
+			'createAntrag' => self::PERM_LOGGED,
+			'cancelAntrag' => self::PERM_LOGGED,
+			'getLvs' => self::PERM_LOGGED,
+			'saveLvs' => ['student/studierendenantrag:w']
+		]);
+
+		// Libraries
+		$this->load->library('AntragLib');
+
+		// 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->terminateWithError('Forbidden', self::ERROR_TYPE_AUTH, REST_Controller::HTTP_FORBIDDEN);
+
+		$result = $this->antraglib->getPrestudentWiederholungsBerechtigt($prestudent_id);
+		$result = $this->getDataOrTerminateWithError($result);
+
+		if (!$result) {
+			$this->terminateWithError(
+				$this->p->t('studierendenantrag', 'error_no_student_no_failed_exam'),
+				self::ERROR_TYPE_AUTH,
+				REST_Controller::HTTP_FORBIDDEN
+			);
+		} elseif ($result == -1) {
+			$result = $this->antraglib->getDetailsForLastAntrag($prestudent_id, Studierendenantrag_model::TYP_WIEDERHOLUNG);
+			$data = $this->getDataOrTerminateWithError($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;
+
+			$this->terminateWithSuccess($data);
+		} elseif ($result == -2) {
+			$result = $this->antraglib->getDetailsForLastAntrag($prestudent_id);
+			$result = $this->getDataOrTerminateWithError($result);
+
+			$this->terminateWithError(
+				$this->p->t('studierendenantrag', 'error_antrag_pending', [
+					'typ' => $this->p->t('studierendenantrag', 'antrag_typ_' . $result->typ)
+				]),
+				self::ERROR_TYPE_GENERAL,
+				REST_Controller::HTTP_BAD_REQUEST
+			);
+		} elseif ($result == -3) {
+			$this->terminateWithError(
+				$this->p->t('studierendenantrag', 'error_stg_blacklist'),
+				self::ERROR_TYPE_GENERAL,
+				REST_Controller::HTTP_BAD_REQUEST
+			);
+		}
+
+		$result = $this->antraglib->getDetailsForNewAntrag($prestudent_id);
+		$data = $this->getDataOrTerminateWithError($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->terminateWithSuccess($data);
+	}
+
+	public function createAntrag()
+	{
+		$this->createAntragWithStatus(true);
+	}
+
+	public function cancelAntrag()
+	{
+		$this->createAntragWithStatus(false);
+	}
+
+	protected function createAntragWithStatus($repeat)
+	{
+		$this->load->library('form_validation');
+
+		$this->form_validation->set_rules('prestudent_id', 'Prestudent ID', 'required');
+		$this->form_validation->set_rules('studiensemester', 'Studiensemester', 'required');
+
+		if (!$this->form_validation->run())
+			$this->terminateWithValidationErrors($this->form_validation->error_array());
+
+		$prestudent_id = $this->input->post('prestudent_id');
+		$studiensemester = $this->input->post('studiensemester');
+
+		$result = $this->antraglib->getPrestudentWiederholungsBerechtigt($prestudent_id);
+		$result = $this->getDataOrTerminateWithError($result);
+
+		if (!$result) {
+			$this->terminateWithError($this->p->t('studierendenantrag', 'error_no_student'), self::ERROR_TYPE_GENERAL);
+		} elseif ($result == -1) {
+			$result = $this->PrestudentstatusModel->getLastStatus($prestudent_id);
+			$result = $this->getDataOrTerminateWithError($result);
+			if (!$result)
+				$this->terminateWithError($this->p->t('studierendenantrag', 'error_no_prestudentstatus', [
+					'prestudent_id' => $prestudent_id
+				]), self::ERROR_TYPE_GENERAL);
+			if (!in_array(current($result)->status_kurzbz, $this->config->item('antrag_prestudentstatus_whitelist')))
+				$this->terminateWithError($this->p->t('studierendenantrag', 'error_no_student'), self::ERROR_TYPE_GENERAL);
+		} elseif ($result == -2) {
+			$this->terminateWithError($this->p->t('studierendenantrag', 'error_antrag_exists'), self::ERROR_TYPE_GENERAL);
+		} elseif ($result == -3) {
+			$this->terminateWithError($this->p->t('studierendenantrag', 'error_stg_blacklist'), self::ERROR_TYPE_GENERAL);
+		}
+
+		$result = $this->antraglib->createWiederholung($prestudent_id, $studiensemester, getAuthUID(), $repeat);
+		$antragId = $this->getDataOrTerminateWithError($result);
+
+		$result = $this->antraglib->getDetailsForAntrag($antragId);
+
+		if (!hasData($result))
+			$this->terminateWithSuccess(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->terminateWithSuccess($data);
+	}
+
+
+	public function getLvs($antrag_id)
+	{
+		$result = $this->antraglib->getLvsForAntrag($antrag_id);
+		if (isError($result)) {
+			$error = getError($result);
+			if ($error == 'Forbidden')
+				$this->terminateWithError(
+					$error,
+					self::ERROR_TYPE_AUTH,
+					REST_Controller::HTTP_FORBIDDEN
+				);
+			$this->terminateWithError(
+				$error,
+				self::ERROR_TYPE_GENERAL
+			);
+		}
+		$lvs = getData($result);
+
+		$this->terminateWithSuccess($lvs);
+	}
+
+	public function saveLvs()
+	{
+		$forbiddenLvs = $this->input->post('forbiddenLvs');
+		$mandatoryLvs = $this->input->post('mandatoryLvs');
+		$antragsLvs = array_merge($forbiddenLvs, $mandatoryLvs);
+
+		if (!$antragsLvs)
+			$this->terminateWithError($this->p->t('studierendenantrag', 'error_no_lv'), self::ERROR_TYPE_GENERAL);
+
+		$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
+			]);
+			$antrag = $this->getDataOrTerminateWithError($result);
+			if (!$antrag)
+				$this->terminateWithError(
+					$this->p->t('studierendenantrag', 'error_no_antrag_found', ['id' => $antrag_id]),
+					self::ERROR_TYPE_GENERAL
+				);
+			$antrag = current($antrag);
+
+			if ($antrag->status != Studierendenantragstatus_model::STATUS_CREATED
+				&& $antrag->status != Studierendenantragstatus_model::STATUS_LVSASSIGNED)
+				$this->terminateWithError(
+					$this->p->t('studierendenantrag', 'error_antrag_locked'),
+					self::ERROR_TYPE_GENERAL
+				);
+		}
+
+		$result = $this->antraglib->saveLvs($insert);
+		$data = $this->getDataOrTerminateWithError($result);
+
+		$this->terminateWithSuccess($data);
+	}
+}

application/controllers/components/Antrag/Abmeldung.php

@@ -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);
-	}
-}

application/controllers/components/Antrag/Leitung.php

@@ -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) ?: []);
-	}
-}

application/controllers/components/Antrag/Wiederholung.php

@@ -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
-		]);
-	}
-}

application/controllers/components/Filter.php

@@ -9,6 +9,7 @@ if (! defined('BASEPATH')) exit('No direct script access allowed');
  * This controller works with JSON calls on the HTTP GET or POST and the output is always JSON
  * NOTE: extends the FHC_Controller instead of the Auth_Controller because the FilterCmpt has its
  * 	own permissions check
+ * TODO(chris): deprecated
  */
 class Filter extends FHC_Controller
 {

application/controllers/components/Phrasen.php

@@ -3,7 +3,7 @@
 if (! defined('BASEPATH')) exit('No direct script access allowed');
 
 /**
- *
+ * TODO(chris): deprecated
  */
 class Phrasen extends FHC_Controller
 {

application/controllers/components/SearchBar.php

@@ -3,7 +3,7 @@
 if (! defined('BASEPATH')) exit('No direct script access allowed');
 
 /**
- *
+ * TODO(chris): deprecated
  */
 class SearchBar extends FHC_Controller
 {

application/controllers/jobs/AntragJob.php

@@ -412,6 +412,8 @@ class AntragJob extends JOB_Controller
 		$this->StudierendenantragModel->addSelect('studiensemester_kurzbz');
 		$this->StudierendenantragModel->addSelect('s.insertamum');
 		$this->StudierendenantragModel->addSelect('s.insertvon');
+		$this->StudierendenantragModel->addJoin('public.tbl_student pts', 'prestudent_id');
+		$this->StudierendenantragModel->addSelect('pts.student_uid');
 
 		$this->StudierendenantragModel->db->where_in(
 			'public.get_rolle_prestudent(prestudent_id, studiensemester_kurzbz)',
@@ -484,7 +486,7 @@ class AntragJob extends JOB_Controller
 						$person = current(getData($result));
 						$email = $studiengang->email;
 						$dataMail = array(
-							'prestudent' => $antrag->prestudent_id,
+							'prestudent' => 'UID: ' . $antrag->student_uid . ', PreStudentId: ' . $antrag->prestudent_id,
 							'studiensemester' => $antrag->studiensemester_kurzbz,
 							'name' => trim($person->vorname . ' '. $person->nachname),
 						);

application/controllers/jobs/IssueResolver.php

@@ -45,6 +45,7 @@ class IssueResolver extends IssueResolver_Controller
 			'CORE_STUDENTSTATUS_0013' => 'CORE_STUDENTSTATUS_0013',
 			'CORE_STUDENTSTATUS_0014' => 'CORE_STUDENTSTATUS_0014',
 			'CORE_STUDENTSTATUS_0015' => 'CORE_STUDENTSTATUS_0015',
+			'CORE_STUDENTSTATUS_0016' => 'CORE_STUDENTSTATUS_0016',
 			'CORE_PERSON_0001' => 'CORE_PERSON_0001',
 			'CORE_PERSON_0002' => 'CORE_PERSON_0002',
 			'CORE_PERSON_0003' => 'CORE_PERSON_0003',

application/controllers/jobs/ReihungstestJob.php

@@ -1023,7 +1023,7 @@ class ReihungstestJob extends JOB_Controller
 			{
 				$studiengang = $this->StudiengangModel->load($stg);
 				$mailcontent = '';
-
+				$content = false;
 				foreach ($orgform AS $art=>$value)
 				{
 					// Orgform nur dazu schreiben, wenn es mehr als Eine gibt
@@ -1044,6 +1044,7 @@ class ReihungstestJob extends JOB_Controller
 							$mailcontent .= '<tr><td style="font-family: verdana, sans-serif; border: 1px solid grey; padding: 3px">'.$bewerber.'</td></tr>';
 						}
 						$mailcontent .= '</tbody></table><br><br>';
+						$content = true;
 					}
 					if (isset($value['AufnahmeHoeherePrio']) && !isEmptyArray($value['AufnahmeHoeherePrio']))
 					{
@@ -1058,6 +1059,7 @@ class ReihungstestJob extends JOB_Controller
 							$mailcontent .= '<tr><td style="font-family: verdana, sans-serif; border: 1px solid grey; padding: 3px">'.$bewerber.'</td></tr>';
 						}
 						$mailcontent .= '</tbody></table>';
+						$content = true;
 					}
 					if (isset($value['AbgewiesenHoeherePrio']) && !isEmptyArray($value['AbgewiesenHoeherePrio']))
 					{
@@ -1071,6 +1073,7 @@ class ReihungstestJob extends JOB_Controller
 							$mailcontent .= '<tr><td style="font-family: verdana, sans-serif; border: 1px solid grey; padding: 3px">'.$bewerber.'</td></tr>';
 						}
 						$mailcontent .= '</tbody></table>';
+						$content = true;
 					}
 					if ($bcc != '' && isset($value['AbgewiesenWeilBewerber']) && !isEmptyArray($value['AbgewiesenWeilBewerber']))
 					{
@@ -1085,13 +1088,14 @@ class ReihungstestJob extends JOB_Controller
 							$mailcontent .= '<tr><td style="font-family: verdana, sans-serif; border: 1px solid grey; padding: 3px">'.$bewerber.'</td></tr>';
 						}
 						$mailcontent .= '</tbody></table>';
+						$content = true;
 					}
 				}
 
 				$mailcontent_data_arr['table'] = $mailcontent;
 
 				// Send email in Sancho design
-				if (!isEmptyString($mailcontent))
+				if (!isEmptyString($mailcontent) && $content === true)
 				{
 					sendSanchoMail(
 						'Sancho_ReihungstestteilnehmerJob',

application/controllers/system/MigrateContract.php

@@ -16,7 +16,9 @@ class MigrateContract extends CLI_Controller
 {
 
 	private $matching_ba1_vertragsart;
-	private $OE_DEFAULT = 'gst';
+	private $OE_DEFAULT;
+
+	protected $configerrors;
 
 	/**
 	 * Constructor
@@ -28,29 +30,70 @@ class MigrateContract extends CLI_Controller
 		$this->load->model('codex/bisverwendung_model', 'BisVerwendungModel');
 		$this->load->model('person/benutzerfunktion_model', 'BenutzerfunktionModel');
 
-		$this->matching_ba1_vertragsart = array(
+		$this->load->config('migratecontract');
-			'101'=>'externerlehrender',
+
-			'102'=>'DV anderen Gebietskörperschaft',
+		$this->OE_DEFAULT = $this->config->item('migratecontract_oe_default');
-			'103'=>'echterdv',
+		$this->matching_ba1_vertragsart = $this->config->item('migratecontract_matching_ba1_vertragsart');
-			'104'=>'studentischehilfskr',
+		$this->configerrors = array();
-			'105'=>'externerlehrender',
-			'106'=>'Andere Bildungseinrichtung',
-			'107'=>'werkvertrag',
-			'108'=>'studentischehilfskr',
-			'109'=>'ueberlassungsvertrag',
-			'110'=>'echterfreier',
-			'111'=>'echterdv', //All-In
-		);
 	}
 
 	// -----------------------------------------------------------------------------------------------------------------
 	// Public methods
+	public function checkConfig()
+	{
+	    echo "OE_DEFAULT: " . $this->OE_DEFAULT . "\n";
+	    echo "matching_ba1_vertragsart: " . print_r($this->matching_ba1_vertragsart, true);
+
+	    $this->checkOE_DEFAULT();
+	    $this->checkMatching_ba1_vertragsart();
+
+	    if( count($this->configerrors) > 0 )
+	    {
+		foreach($this->configerrors AS $configerror)
+		{
+		    echo $configerror . "\n";
+		}
+		die("Fehler in der Konfiguration. Abbruch!\n");
+	    }
+	    else
+	    {
+		echo "Konfiguration OK.\n";
+	    }
+	}
+
+	protected function checkOE_DEFAULT()
+	{
+	    $db = new DB_Model();
+	    $oesql = 'SELECT * FROM public.tbl_organisationseinheit WHERE oe_kurzbz = ?';
+	    $oeres = $db->execReadOnlyQuery($oesql, array($this->OE_DEFAULT));
+	    if( !hasData($oeres) )
+	    {
+		$this->configerrors[] = 'Default Organisationseinheit: "'
+		    . $this->OE_DEFAULT . '" nicht gefunden.';
+	    }
+	}
+
+	protected function checkMatching_ba1_vertragsart() {
+	    $db = new DB_Model();
+	    foreach( $this->matching_ba1_vertragsart AS $vertragsart_kurzbz )
+	    {
+		$vasql = 'SELECT * FROM hr.tbl_vertragsart WHERE vertragsart_kurzbz = ?';
+		$vares = $db->execReadOnlyQuery($vasql, array($vertragsart_kurzbz));
+		if( !hasData($vares) )
+		{
+		    $this->configerrors[] = 'Vertragsart "' . $vertragsart_kurzbz
+			. '" nicht gefunden.';
+		}
+	    }
+	}
 
 	/**
 	 * Everything has a beginning
 	 */
 	public function index($user = null)
 	{
+		$this->checkConfig();
+
 		if (!is_null($user))
 		{
 			$contracts = $this->_transformUser($user);
@@ -400,6 +443,11 @@ class MigrateContract extends CLI_Controller
 	 */
 	private function _addVertragsbestandteilZeitaufzeichnung(&$contracts, $dv, $row_verwendung)
 	{
+		if( is_null($row_verwendung->zeitaufzeichnungspflichtig) || is_null($row_verwendung->azgrelevant) )
+		{
+		    return;
+		}
+
 		if (isset($contracts['dv'][$dv]['vbs']))
 		{
 			foreach ($contracts['dv'][$dv]['vbs'] as $index_vbs=>$row_vbs)

application/controllers/system/MigrateHourlyRate.php

@@ -4,14 +4,15 @@ 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 $OE_DEFAULT;
 	private $_ci;
 
+	protected $configerrors;
+
 	public function __construct()
 	{
 		parent::__construct();
@@ -21,10 +22,38 @@ class MigrateHourlyRate extends CLI_Controller
 		$this->load->model('codex/Bisverwendung_model', 'BisVerwendungModel');
 		$this->load->model('person/Benutzerfunktion_model', 'BenutzerfunktionModel');
 		$this->load->model('ressource/Stundensatz_model', 'StundensatzModel');
+
+		$this->load->config('migratecontract');
+
+		$this->OE_DEFAULT = $this->config->item('migratecontract_oe_default');
+		$this->configerrors = array();
+	}
+
+	public function checkConfig()
+	{
+	    echo "OE_DEFAULT: " . $this->OE_DEFAULT . "\n";
+
+	    $this->checkOE_DEFAULT();
+
+	    if( count($this->configerrors) > 0 )
+	    {
+		foreach($this->configerrors AS $configerror)
+		{
+		    echo $configerror . "\n";
+		}
+		die("Fehler in der Konfiguration. Abbruch!\n");
+	    }
+	    else
+	    {
+		echo "Konfiguration OK.\n";
+	    }
 	}
 
 	public function index($user = null)
 	{
+		$this->checkConfig();
+
+		echo "Lehre Stundensaetze werden migriert.\n";
 		$mitarbeiterResult = $this->_getMitarbeiterStunden($user);
 		if (isError($mitarbeiterResult)) return $mitarbeiterResult;
 		if (!hasData($mitarbeiterResult)) return error('Keine Mitarbeiterstunden gefunden');
@@ -38,20 +67,71 @@ class MigrateHourlyRate extends CLI_Controller
 			if (isError($insertResult)) return $insertResult;
 		}
 		
-		$sapResult = $this->_getSapStunden($user);
+		if( $this->checkIfSAPSyncTableExists() )
-		if (isError($sapResult)) return $sapResult;
-		if (!hasData($sapResult)) return error('Keinen kalkulatorischen Stundensaetze gefunden');
-
-		$mitarbeiterArray = getData($sapResult);
-
-		foreach ($mitarbeiterArray as $mitarbeiter)
 		{
-			$this->_getUnternehmen($mitarbeiter);
+			echo "SAP Sync Tabelle gefunden. SAP Stundensaetze werden migriert.\n";
-			$insertResult = $this->_addStundensatz($mitarbeiter, self::STUNDENSTAZTYP_KALKULATORISCH, date_format(date_create($mitarbeiter->beginn), 'Y-m-d'));
+			$sapResult = $this->_getSapStunden($user);
-			if (isError($insertResult)) return $insertResult;
+			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;
+			}
+		}
+		else
+		{
+		    echo "SAP Sync Tabelle nicht gefunden. Ignoriere SAP Stundensaetze.\n";
 		}
 	}
 
+	protected function checkOE_DEFAULT()
+	{
+	    $db = new DB_Model();
+	    $oesql = 'SELECT * FROM public.tbl_organisationseinheit WHERE oe_kurzbz = ?';
+	    $oeres = $db->execReadOnlyQuery($oesql, array($this->OE_DEFAULT));
+	    if( !hasData($oeres) )
+	    {
+		$this->configerrors[] = 'Default Organisationseinheit: "'
+		    . $this->OE_DEFAULT . '" nicht gefunden.';
+	    }
+	}
+
+	protected function checkIfSAPSyncTableExists()
+	{
+	    $dbModel = new DB_Model();
+	    $params = array(
+		DB_NAME,
+		'sync',
+		'tbl_sap_stundensatz'
+	    );
+
+	    $sql = "SELECT
+			    1 AS exists
+		    FROM
+			    information_schema.tables
+		    WHERE
+			    table_catalog = ? AND
+			    table_schema = ? AND
+			    table_name = ?";
+
+	    $res = $dbModel->execReadOnlyQuery($sql, $params);
+
+	    if( hasData($res) )
+	    {
+		return true;
+	    }
+	    else
+	    {
+		return false;
+	    }
+	}
+
+
 	private function _getSapStunden($user = null)
 	{
 		$dbModel = new DB_Model();
@@ -127,7 +207,7 @@ class MigrateHourlyRate extends CLI_Controller
 			$unternehmenResult = $this->_findUnternehmen($mitarbeiter->uid, "'kstzuordnung', 'oezuordnung'");
 		}
 
-		$unternehmen = self::DEFAULT_OE;
+		$unternehmen = $this->OE_DEFAULT;
 
 		if (hasData($unternehmenResult))
 			$unternehmen = getData($unternehmenResult)[0]->oe_kurzbz;

application/controllers/system/Navigation.php

@@ -22,6 +22,7 @@ if (! defined('BASEPATH')) exit('No direct script access allowed');
  * This controller operates between (interface) the JS (GUI) and the NavigationLib (back-end)
  * Provides data to the ajax get calls about the filter
  * This controller works with JSON calls on the HTTP GET or POST and the output is always JSON
+ * TODO(chris): deprecated
  */
 class Navigation extends FHC_Controller
 {

application/core/Auth_Controller.php

@@ -7,6 +7,10 @@ if (!defined('BASEPATH')) exit('No direct script access allowed');
  */
 abstract class Auth_Controller extends FHC_Controller
 {
+	// Special Permissions
+	const PERM_ANONYMOUS = 'anonymous'; // Everyone
+	const PERM_LOGGED = 'logged_in'; // Every registered user
+
 	/**
 	 * Extends this controller if authentication is required
 	 */
@@ -14,17 +18,41 @@ abstract class Auth_Controller extends FHC_Controller
 	{
         parent::__construct();
 
-		// Loads authentication library and starts authentication
+		if (!is_array($requiredPermissions) || isEmptyArray($requiredPermissions))
-		$this->load->library('AuthLib');
+			show_error('The given permissions is not a valid array or it is an empty one');
+		
+		if (!isset($requiredPermissions[$this->router->method]))
+			show_error('The given permission array does not contain the given method or is not correctly set');
+		
+		$anonAllowed = false;
+		if ($requiredPermissions[$this->router->method] == self::PERM_ANONYMOUS)
+			$anonAllowed = true;
+		elseif (is_array($requiredPermissions[$this->router->method])
+			&& in_array(self::PERM_ANONYMOUS, $requiredPermissions[$this->router->method]))
+			$anonAllowed = true;
 
-		// Checks if the caller is allowed to access to this content
+		if ($anonAllowed) {
-		$this->_isAllowed($requiredPermissions);
+			// Loads authentication library without authentication
+			$this->load->library('AuthLib', [false]);
+
+			// Loads helper since it would only be called on authentication
+			$this->load->helper('hlp_authentication');
+		} else {
+			// Loads authentication library and starts authentication
+			$this->load->library('AuthLib');
+
+			// Checks if the caller is allowed to access to this content
+			$this->_isAllowed($requiredPermissions);
+		}
 	}
 
 	/**
 	 * 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
 	 */
 	private function _isAllowed($requiredPermissions)
 	{
@@ -34,28 +62,43 @@ abstract class Auth_Controller extends FHC_Controller
 		// 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->_outputAuthError($requiredPermissions);
-
-			$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
 		}
 	}
 
+	/**
+	 * Outputs an error message and sets the HTTP Header.
+	 * This function is protected so that it can be overwritten.
+	 *
+	 * @param array					$requiredPermissions
+	 * @return void
+	 */
+	protected function _outputAuthError($requiredPermissions)
+	{
+		$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));
+	}
+
 	/**
 	 * 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
 	 */
-	private function _rpsToString($requiredPermissions, $method)
+	final protected function _rpsToString($requiredPermissions, $method)
 	{
 		$strRequiredPermissions = ''; // string that contains all the required permissions needed to access to this method
 

application/core/FHCAPI_Controller.php

@@ -5,7 +5,7 @@ if (!defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * Controller using JSON
  */
-class FHCAPI_Controller extends FHC_Controller
+class FHCAPI_Controller extends Auth_Controller
 {
 
 	/**
@@ -19,12 +19,13 @@ class FHCAPI_Controller extends FHC_Controller
 	/**
 	 * Error types
 	 */
-	const ERROR_TYPE_PHP = 'php'; // TODO(chris): php types from severity?
+	const ERROR_TYPE_PHP = 'php';
 	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';
+	const ERROR_TYPE_AUTH = 'auth';
 
 	/**
 	 * Return Object
@@ -45,10 +46,6 @@ class FHCAPI_Controller extends FHC_Controller
 		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;
 
@@ -74,18 +71,14 @@ class FHCAPI_Controller extends FHC_Controller
 				}
 			}
 
-			#$this->returnObj['test'] = implode('/n', headers_list());
-
 			return json_encode($this->returnObj);
 		});
 
-		// Load libraries
+		// NOTE(chris): overwrite error_views_path before constructor
-		$this->load->library('AuthLib');
+		load_class('Config')->set_item('error_views_path', VIEWPATH.'errors'.DIRECTORY_SEPARATOR.'json'.DIRECTORY_SEPARATOR);
-		$this->load->library('PermissionLib');
-
-		// Checks if the caller is allowed to access to this content
-		$this->_isAllowed($requiredPermissions);
 
+		parent::__construct($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);
@@ -136,15 +129,25 @@ class FHCAPI_Controller extends FHC_Controller
 		$this->returnObj['data'] = $data;
 	}
 
+	/**
+	 * @param string				$key
+	 * @param mixed					$value
+	 * @return void
+	 */
+	public function addMeta($key, $value)
+	{
+		if (!isset($this->returnObj['meta']))
+			$this->returnObj['meta'] = [];
+		$this->returnObj['meta'][$key] = $value;
+	}
+
 	/**
 	 * @param string				$status
 	 * @return void
 	 */
 	public function setStatus($status)
 	{
-		if (!isset($this->returnObj['meta']))
+		$this->addMeta('status', $status);
-			$this->returnObj['meta'] = [];
-		$this->returnObj['meta']['status'] = $status;
 	}
 
 
@@ -152,6 +155,17 @@ class FHCAPI_Controller extends FHC_Controller
 	// Handle Output object - Shortcut functions
 	// ---------------------------------------------------------------
 
+	/**
+	 * @param mixed					$data (optional)
+	 * @return void
+	 */
+	protected function terminateWithSuccess($data = null)
+	{
+		$this->setData($data);
+		$this->setStatus(self::STATUS_SUCCESS);
+		exit;
+	}
+
 	/**
 	 * @param array					$errors
 	 * @return void
@@ -164,25 +178,15 @@ class FHCAPI_Controller extends FHC_Controller
 		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)
+	 * @param integer				$status (optional)
 	 * @return void
 	 */
-	protected function terminateWithError($error, $type = null)
+	protected function terminateWithError($error, $type = null, $status = REST_Controller::HTTP_INTERNAL_SERVER_ERROR)
 	{
-		$this->output->set_status_header(REST_Controller::HTTP_INTERNAL_SERVER_ERROR);
+		$this->output->set_status_header($status);
 		$this->addError($error, $type);
 		$this->setStatus(self::STATUS_ERROR);
 		exit;
@@ -193,63 +197,35 @@ class FHCAPI_Controller extends FHC_Controller
 	 * @param string				$errortype
 	 * @return void
 	 */
-	protected function checkForErrors($result, $errortype = self::ERROR_TYPE_GENERAL)
+	protected function getDataOrTerminateWithError($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
+	 * Outputs an error message and sets the HTTP Header.
-	 * If it is not allowed will set the HTTP header with code 401
+	 * This overwrites the default behaviour to output a json object.
-	 * Wrapper for permissionlib->isEntitled
 	 *
 	 * @param array					$requiredPermissions
 	 * @return void
 	 */
-	protected function _isAllowed($requiredPermissions)
+	protected function _outputAuthError($requiredPermissions)
 	{
-		// Checks if this user is entitled to access to this content
+		$this->output->set_status_header(isLogged() ? REST_Controller::HTTP_FORBIDDEN : REST_Controller::HTTP_UNAUTHORIZED);
-		if (!$this->permissionlib->isEntitled($requiredPermissions, $this->router->method))
-		{
-			$this->output->set_status_header(isLogged() ? REST_Controller::HTTP_FORBIDDEN : REST_Controller::HTTP_UNAUTHORIZED);
 
-			$this->addError([
+		$this->addError([
-				'message' => 'You are not allowed to access to this content',
+			'message' => 'You are not allowed to access to this content',
-				'controller' => $this->router->class,
+			'controller' => $this->router->class,
-				'method' => $this->router->method,
+			'method' => $this->router->method,
-				'required_permissions' => $this->_rpsToString($requiredPermissions, $this->router->method)
+			'required_permissions' => $this->_rpsToString($requiredPermissions, $this->router->method)
-			]);
+		], self::ERROR_TYPE_AUTH);
-			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]);
 	}
 }

application/libraries/AntragLib.php

@@ -2058,7 +2058,7 @@ class AntragLib
 	 */
 	public function isEntitledToUnpauseAntrag($antrag_id)
 	{
-		return $this->hasAccessToAntrag($antrag_id, 'student/studierendenantrag');
+		return ($this->hasAccessToAntrag($antrag_id, 'student/antragfreigabe') || $this->hasAccessToAntrag($antrag_id, 'student/studierendenantrag'));
 	}
 
 	/**

application/libraries/PermissionLib.php

@@ -21,6 +21,8 @@ require_once(FHCPATH.'include/functions.inc.php');
 require_once(FHCPATH.'include/wawi_kostenstelle.class.php');
 require_once(FHCPATH.'include/benutzerberechtigung.class.php');
 
+use \benutzerberechtigung as benutzerberechtigung;
+
 class PermissionLib
 {
 	// Available rights in the DB
@@ -65,8 +67,10 @@ class PermissionLib
 		if (!is_cli())
 		{
 			// API Caller rights initialization
+			$authObj = $this->_ci->authlib->getAuthObj();
 			self::$bb = new benutzerberechtigung();
-			self::$bb->getBerechtigungen(($this->_ci->authlib->getAuthObj())->{AuthLib::AO_USERNAME});
+			if ($authObj)
+				self::$bb->getBerechtigungen($authObj->{AuthLib::AO_USERNAME});
 		}
 	}
 
@@ -166,6 +170,16 @@ class PermissionLib
 									if ($checkPermissions === true) break;
 								}
 							}
+							elseif ($permissions[$pCounter] == Auth_Controller::PERM_ANONYMOUS)
+							{
+								$checkPermissions = true;
+								break;
+							}
+							elseif ($permissions[$pCounter] == Auth_Controller::PERM_LOGGED)
+							{
+								$checkPermissions = isLogged();
+								break;
+							}
 							else
 							{
 								show_error('The given permission does not use the correct format');

application/libraries/issues/PlausicheckDefinitionLib.php

@@ -33,7 +33,8 @@ class PlausicheckDefinitionLib
 		'PrestudentMischformOhneOrgform' => 'PrestudentMischformOhneOrgform',
 		'StgPrestudentUngleichStgStudienplan' => 'StgPrestudentUngleichStgStudienplan',
 		'StgPrestudentUngleichStgStudent' => 'StgPrestudentUngleichStgStudent',
-		'StudentstatusNachAbbrecher' => 'StudentstatusNachAbbrecher'
+		'StudentstatusNachAbbrecher' => 'StudentstatusNachAbbrecher',
+		'DualesStudiumOhneMarkierung' => 'DualesStudiumOhneMarkierung'
 		//'StudienplanUngueltig' => 'StudienplanUngueltig'
 	);
 

application/libraries/issues/PlausicheckProducerLib.php

@@ -12,8 +12,7 @@ class PlausicheckProducerLib
 
 	private $_ci; // ci instance
 	private $_extensionName; // name of extension
-	private $_app; // name of application
+	private $_konfiguration = array(); // configuration parameters
-	private $_konfiguration = array(); // konfigratio parameters
 
 	public function __construct($params = null)
 	{

application/libraries/issues/plausichecks/DualesStudiumOhneMarkierung.php

@@ -0,0 +1,143 @@
+<?php
+
+if (! defined('BASEPATH')) exit('No direct script access allowed');
+
+require_once('PlausiChecker.php');
+
+/**
+ *
+ */
+class DualesStudiumOhneMarkierung extends PlausiChecker
+{
+	public function executePlausiCheck($params)
+	{
+		$results = array();
+
+		// get parameters from config
+		$exkludierte_studiengang_kz = isset($this->_config['exkludierteStudiengaenge']) ? $this->_config['exkludierteStudiengaenge'] : null;
+
+		// pass parameters needed for plausicheck
+		$studiensemester_kurzbz = isset($params['studiensemester_kurzbz']) ? $params['studiensemester_kurzbz'] : null;
+		$studiengang_kz = isset($params['studiengang_kz']) ? $params['studiengang_kz'] : null;
+
+		// get all students failing the plausicheck
+		$prestudentRes = $this->getDualesStudiumOhneMarkierung(
+			$studiensemester_kurzbz,
+			$studiengang_kz,
+			null,
+			$exkludierte_studiengang_kz
+		);
+
+		if (isError($prestudentRes)) return $prestudentRes;
+
+		if (hasData($prestudentRes))
+		{
+			$prestudents = getData($prestudentRes);
+
+			// populate results with data necessary for writing issues
+			foreach ($prestudents as $prestudent)
+			{
+				$results[] = array(
+					'person_id' => $prestudent->person_id,
+					'oe_kurzbz' => $prestudent->prestudent_stg_oe_kurzbz,
+					'fehlertext_params' => array(
+						'prestudent_id' => $prestudent->prestudent_id,
+						'studienplan' => $prestudent->studienplan
+					),
+					'resolution_params' => array(
+						'prestudent_id' => $prestudent->prestudent_id,
+						'studiensemester_kurzbz' => $prestudent->studiensemester_kurzbz
+					)
+				);
+			}
+		}
+
+		// return the results
+		return success($results);
+	}
+
+	/**
+	 * All prestudents in dual Studiengang should have set the dual flag to true.
+	 * @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
+	 * @param studiengang_kz int if check is to be executed for certain Studiengang
+	 * @param prestudent_id int if check is to be executed only for one prestudent
+	 * @param exkludierte_studiengang_kz array if certain Studiengänge have to be excluded from check
+	 * @return success with prestudents or error
+	 */
+	public function getDualesStudiumOhneMarkierung(
+		$studiensemester_kurzbz,
+		$studiengang_kz = null,
+		$prestudent_id = null,
+		$exkludierte_studiengang_kz = null
+	) {
+		$params = array($studiensemester_kurzbz);
+
+		$qry = "
+			SELECT
+				DISTINCT pre.person_id, pre.prestudent_id,
+				stpl.bezeichnung AS studienplan,
+				status.studiensemester_kurzbz,
+				status.ausbildungssemester,
+				stg.oe_kurzbz AS prestudent_stg_oe_kurzbz
+			FROM
+				public.tbl_prestudent pre
+				JOIN public.tbl_prestudentstatus status USING(prestudent_id)
+				JOIN public.tbl_person USING(person_id)
+				JOIN lehre.tbl_studienplan stpl USING(studienplan_id)
+				JOIN public.tbl_studiengang stg ON pre.studiengang_kz = stg.studiengang_kz
+				JOIN public.tbl_studiensemester sem USING(studiensemester_kurzbz)
+			WHERE
+				(stpl.orgform_kurzbz = 'DUA' OR status.orgform_kurzbz = 'DUA')
+				AND pre.dual = FALSE
+				AND status.studiensemester_kurzbz=?
+				AND pre.bismelden
+				AND stg.melderelevant
+				AND NOT EXISTS (
+					SELECT 1
+					FROM
+						public.tbl_prestudentstatus
+						JOIN lehre.tbl_studienplan USING(studienplan_id)
+						JOIN public.tbl_studiensemester USING(studiensemester_kurzbz)
+					WHERE
+						prestudent_id = pre.prestudent_id
+						AND
+						(
+							-- if there is a newer non-dual status, dual has not to be set
+							(
+								(
+									tbl_studienplan.orgform_kurzbz <> stpl.orgform_kurzbz
+									OR status.orgform_kurzbz <> tbl_prestudentstatus.orgform_kurzbz
+								)
+								AND
+								(
+									tbl_studiensemester.ende::date > sem.ende::date
+									OR (tbl_studiensemester.ende::date = sem.ende::date AND tbl_prestudentstatus.datum::date > status.datum::date)
+								)
+							)
+							OR
+								-- exclude Abgewiesene - they are not reported
+								tbl_prestudentstatus.status_kurzbz = 'Abgewiesener'
+						)
+				)";
+
+		if (isset($studiengang_kz))
+		{
+			$qry .= " AND stg.studiengang_kz = ?";
+			$params[] = $studiengang_kz;
+		}
+
+		if (isset($prestudent_id))
+		{
+			$qry .= " AND pre.prestudent_id = ?";
+			$params[] = $prestudent_id;
+		}
+
+		if (isset($exkludierte_studiengang_kz) && !isEmptyArray($exkludierte_studiengang_kz))
+		{
+			$qry .= " AND stg.studiengang_kz NOT IN ?";
+			$params[] = $exkludierte_studiengang_kz;
+		}
+
+		return $this->_db->execReadOnlyQuery($qry, $params);
+	}
+}

application/libraries/issues/plausichecks/InaktiverStudentAktiverStatus.php

@@ -67,6 +67,7 @@ class InaktiverStudentAktiverStatus extends PlausiChecker
 		$prestudent_id = null,
 		$exkludierte_studiengang_kz = null
 	) {
+		$this->_ci->load->model('organisation/studiensemester_model', 'StudiensemesterModel');
 		$aktStudiensemesterRes = $this->_ci->StudiensemesterModel->getAkt();
 
 		if (isError($aktStudiensemesterRes)) return $aktStudiensemesterRes;

application/libraries/issues/resolvers/CORE_STUDENTSTATUS_0016.php

@@ -0,0 +1,36 @@
+<?php
+
+if (! defined('BASEPATH')) exit('No direct script access allowed');
+
+/**
+ * Student in dual Studiengang should have set the dual flag to true.
+ */
+class CORE_STUDENTSTATUS_0016 implements IIssueResolvedChecker
+{
+	public function checkIfIssueIsResolved($params)
+	{
+		if (!isset($params['prestudent_id']) || !is_numeric($params['prestudent_id']))
+			return error('Prestudent Id missing, issue_id: '.$params['issue_id']);
+
+		if (!isset($params['studiensemester_kurzbz']) || isEmptyString($params['studiensemester_kurzbz']))
+			return error('Studiensemester missing, issue_id: '.$params['issue_id']);
+
+		$this->_ci =& get_instance(); // get code igniter instance
+
+		$this->_ci->load->library('issues/plausichecks/DualesStudiumOhneMarkierung');
+
+		// check if issue persists
+		$checkRes = $this->_ci->dualesstudiumohnemarkierung->getDualesStudiumOhneMarkierung(
+			$params['studiensemester_kurzbz'],
+			null,
+			$params['prestudent_id']
+		);
+
+		if (isError($checkRes)) return $checkRes;
+
+		if (hasData($checkRes))
+			return success(false); // not resolved if issue is still present
+		else
+			return success(true); // resolved otherwise
+	}
+}

application/libraries/vertragsbestandteil/Dienstverhaeltnis.php

@@ -29,6 +29,9 @@ class Dienstverhaeltnis extends AbstractBestandteil {
 	protected $updateamum;
 	protected $updatevon;
 
+	protected $dvendegrund_kurzbz;
+	protected $dvendegrund_anmerkung;
+
 	public function __construct()
 	{
 		parent::__construct();
@@ -49,6 +52,8 @@ class Dienstverhaeltnis extends AbstractBestandteil {
 		isset($data->insertvon) && $this->setInsertvon($data->insertvon);
 		isset($data->updateamum) && $this->setUpdateamum($data->updateamum);
 		isset($data->updatevon) && $this->setUpdatevon($data->updatevon);
+		isset($data->dvendegrund_kurzbz) && $this->setDvendegrund_kurzbz($data->dvendegrund_kurzbz);
+		isset($data->dvendegrund_anmerkung) && $this->setDvendegrund_anmerkung($data->dvendegrund_anmerkung);
 		$this->fromdb = false;
 	}
 	
@@ -64,7 +69,9 @@ class Dienstverhaeltnis extends AbstractBestandteil {
 			'insertamum' => $this->getInsertamum(),
 			'insertvon' => $this->getInsertvon(),
 			'updateamum' => $this->getUpdateamum(),
-			'updatevon' => $this->getUpdatevon()
+			'updatevon' => $this->getUpdatevon(), 
+			'dvendegrund_kurzbz' => $this->getDvendegrund_kurzbz(), 
+			'dvendegrund_anmerkung' => $this->getDvendegrund_anmerkung()
 		);
 		
 		$tmp = array_filter($tmp, function($k) {
@@ -139,6 +146,16 @@ EOTXT;
 		return $this->updatevon;
 	}
 
+	public function getDvendegrund_kurzbz()
+	{
+	    return $this->dvendegrund_kurzbz;
+	}
+
+	public function getDvendegrund_anmerkung()
+	{
+	    return $this->dvendegrund_anmerkung;
+	}
+
 	public function setDienstverhaeltnis_id($dienstverhaeltnis_id)
 	{
 		$this->markDirty('dienstverhaeltnis_id', $this->dienstverhaeltnis_id, $dienstverhaeltnis_id);
@@ -214,6 +231,20 @@ EOTXT;
 		return $this;
 	}
 	
+	public function setDvendegrund_kurzbz($dvendegrund_kurzbz)
+	{
+	    $this->markDirty('dvendegrund_kurzbz', $this->dvendegrund_kurzbz, $dvendegrund_kurzbz);
+	    $this->dvendegrund_kurzbz = $dvendegrund_kurzbz;
+	    return $this;
+	}
+
+	public function setDvendegrund_anmerkung($dvendegrund_anmerkung)
+	{
+	    $this->markDirty('dvendegrund_anmerkung', $this->dvendegrund_anmerkung, $dvendegrund_anmerkung);
+	    $this->dvendegrund_anmerkung = $dvendegrund_anmerkung;
+	    return $this;
+	}
+
 	public function validate() {		
 		//do Validation here
 		$ci = get_instance();

application/libraries/vertragsbestandteil/VertragsbestandteilLib.php

@@ -435,7 +435,7 @@ class VertragsbestandteilLib
 	    return $result;
 	}
 
-	public function endDienstverhaeltnis(Dienstverhaeltnis $dv, $enddate)
+	public function endDienstverhaeltnis(Dienstverhaeltnis $dv, $enddate, $dvendegrund_kurzbz=null, $dvendegrund_anmerkung=null)
 	{
 		if( $dv->getBis() !== null && $dv->getBis() < $enddate )
 		{
@@ -460,6 +460,14 @@ class VertragsbestandteilLib
 					$this->endVertragsbestandteil($vb, $enddate);
 				}
 
+				if( $dvendegrund_kurzbz !== null )
+				{
+				    $dv->setDvendegrund_kurzbz($dvendegrund_kurzbz);
+				}
+				if( $dvendegrund_anmerkung !== null )
+				{
+				    $dv->setDvendegrund_anmerkung($dvendegrund_anmerkung);
+				}
 				$dv->setBis($enddate);
 				$this->updateDienstverhaeltnis($dv);
 

application/models/organisation/Organisationseinheit_model.php

@@ -188,4 +188,20 @@ class Organisationseinheit_model extends DB_Model
         }
         return $this->loadWhere($condition);
     }
+
+	/**
+	 * Get OEs by eventQuery string. Use with autocomplete event queries.
+	 * @param $eventQuery String
+	 * @return array
+	 */
+	public function getAutocompleteSuggestions($eventQuery)
+	{
+		$this->addSelect('oe_kurzbz');
+		$this->addSelect('organisationseinheittyp_kurzbz, oe_kurzbz, bezeichnung, aktiv, lehre');
+		$this->addOrder('organisationseinheittyp_kurzbz, bezeichnung');
+
+		return $this->loadWhere("
+			oe_kurzbz ILIKE '%". $this->escapeLike($eventQuery). "%'
+		");
+	}
 }

application/models/organisation/Studiengang_model.php

@@ -563,7 +563,7 @@ class Studiengang_model extends DB_Model
 		$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_in('ps.status_kurzbz', $this->config->item('antrag_prestudentstatus_whitelist_abmeldung'));
 		$this->db->where($this->dbTable . ".aktiv", true);
 
 		if ($not_antrag_typ !== null && is_array($not_antrag_typ)) {

application/models/vertragsbestandteil/Dienstverhaeltnis_model.php

@@ -31,9 +31,13 @@ class Dienstverhaeltnis_model extends DB_Model
             org.bezeichnung oe_bezeichnung,
             dv.von,
             dv.bis,
+	    dv.dvendegrund_kurzbz,
+	    dv.dvendegrund_anmerkung,
             dv.vertragsart_kurzbz,
             dv.updateamum,
-            dv.updatevon
+            dv.updatevon,
+            dv.dvendegrund_kurzbz,
+            dv.dvendegrund_anmerkung
         FROM tbl_mitarbeiter
             JOIN tbl_benutzer ON tbl_mitarbeiter.mitarbeiter_uid::text = tbl_benutzer.uid::text
             JOIN tbl_person USING (person_id)

application/views/lehre/Antrag/Create.php

@@ -11,6 +11,7 @@ $sitesettings = array(
 	'customJSModules' => array('public/js/apps/lehre/Antrag.js'),
 	'customCSSs' => array(
 		'public/css/Fhc.css',
+		'public/css/components/primevue.css',
 		'vendor/vuejs/vuedatepicker_css/main.css'
 	),
 	'customJSs' => array(

application/views/lehre/Antrag/Leitung/List.php

@@ -20,7 +20,8 @@ $sitesettings = array(
 	),
 	'customJSModules' => array('public/js/apps/lehre/Antrag/Leitung.js'),
 	'customCSSs' => array(
-		'public/css/Fhc.css'
+		'public/css/Fhc.css',
+		'public/css/components/primevue.css',
 	),
 	'customJSs' => array(
 	)

application/views/lehre/Antrag/Student/List.php

@@ -10,7 +10,8 @@ $sitesettings = array(
 	),
 	'customJSModules' => array('public/js/apps/lehre/Antrag/Student.js'),
 	'customCSSs' => array(
-		'public/css/Fhc.css'
+		'public/css/Fhc.css',
+		'public/css/components/primevue.css',
 	),
 	'customJSs' => array(
 	)
@@ -149,8 +150,6 @@ $this->load->view(
 											break;
 										case Studierendenantrag_model::TYP_ABMELDUNG_STGL:
 											$allowed = [
-												Studierendenantragstatus_model::STATUS_APPROVED,
-												Studierendenantragstatus_model::STATUS_OBJECTED,
 												Studierendenantragstatus_model::STATUS_OBJECTION_DENIED,
 												Studierendenantragstatus_model::STATUS_DEREGISTERED
 											];

application/views/lehre/Antrag/Wiederholung/Student.php

@@ -14,6 +14,8 @@ $sitesettings = array(
 	),
 	'customJSModules' => array('public/js/apps/lehre/Antrag/Lvzuweisung.js'),
 	'customCSSs' => array(
+		'public/css/Fhc.css',
+		'public/css/components/primevue.css',
 	),
 	'customJSs' => array(
 	)
@@ -30,7 +32,7 @@ $this->load->view(
 		<h1 class="h2"><?= $this->p->t('studierendenantrag', 'title_lvzuweisen', ['name' => $antrag->name]);?></h1>
 	</div>
 	<div class="fhc-container row mt-3">
-		<lv-zuweisung antrag-id="<?= $antrag_id; ?>" initial-status-code="<?= $antrag->status; ?>" initial-status-msg="<?= $antrag->statustyp; ?>"<?= ($antrag->status != Studierendenantragstatus_model::STATUS_CREATED && $antrag->status != Studierendenantragstatus_model::STATUS_LVSASSIGNED) ? ' disabled' : ''; ?>></lv-zuweisung>
+		<lv-zuweisung :antrag-id="<?= $antrag_id; ?>" initial-status-code="<?= $antrag->status; ?>" initial-status-msg="<?= $antrag->statustyp; ?>"<?= ($antrag->status != Studierendenantragstatus_model::STATUS_CREATED && $antrag->status != Studierendenantragstatus_model::STATUS_LVSASSIGNED) ? ' disabled' : ''; ?>></lv-zuweisung>
 	</div>
 </div>
 

application/views/system/logs/testSearch.php

@@ -1,13 +1,12 @@
 <?php
 	$includesArray = array(
 		'title' => 'Test Search',
-		'jquery3' => true,
 		'bootstrap5' => true,
 		'fontawesome6' => true,
-		'tablesorter2' => true,
+		'tabulator5' => true,
+		'primevue3' => true,
+		'axios027' => true,
 		'vue3' => true,
-		'ajaxlib' => true,
-		'jqueryui1' => true,
 		'filtercomponent' => true,
 		'navigationcomponent' => true,
 		'phrases' => array(
@@ -17,8 +16,8 @@
 		'customCSSs' => array(
 			'public/css/components/verticalsplit.css',
 			'public/css/components/searchbar.css',
+			'public/css/components/primevue.css',
 		),
-		'customJSs' => array('vendor/axios/axios/axios.min.js'),
 		'customJSModules' => array('public/js/apps/TestSearch.js')
 	);
 
@@ -40,17 +39,17 @@
 			</div>
 			<div>
 
-				<searchbar :searchoptions="searchbaroptions" :searchfunction="searchfunction"></searchbar>
+				<core-searchbar :searchoptions="searchbaroptions" :searchfunction="searchfunction"></core-searchbar>
 				
-				<verticalsplit>
+				<core-verticalsplit>
 					<template #top>
-						<searchbar :searchoptions="searchbaroptions" :searchfunction="searchfunctiondummy"></searchbar>
+						<core-searchbar :searchoptions="searchbaroptions" :searchfunction="searchfunctiondummy"></core-searchbar>
 					</template>
 					<template #bottom>
 						<!-- Filter component -->
 						<core-filter-cmpt filter-type="LogsViewer" @nw-new-entry="newSideMenuEntryHandler"></core-filter-cmpt>
 					</template>
-				</verticalsplit>				
+				</core-verticalsplit>				
 
 			</div>
 		</div>

application/views/templates/FHC-Footer.php

@@ -127,6 +127,11 @@
 		generateJSsInclude('vendor/npm-asset/primevue/autocomplete/autocomplete.min.js');
 		generateJSsInclude('vendor/npm-asset/primevue/overlaypanel/overlaypanel.min.js');
 		generateJSsInclude('vendor/npm-asset/primevue/datatable/datatable.min.js');
+        // TODO check ob notwendig
+		generateJSsInclude('vendor/npm-asset/primevue/toast/toast.min.js');
+		generateJSsInclude('vendor/npm-asset/primevue/toastservice/toastservice.min.js');
+		generateJSsInclude('vendor/npm-asset/primevue/confirmdialog/confirmdialog.min.js');
+		generateJSsInclude('vendor/npm-asset/primevue/confirmationservice/confirmationservice.min.js');
 	}
 
 	// --------------------------------------------------------------------------------------------------------

cis/private/info/service_uebersicht.php

@@ -45,25 +45,22 @@ echo '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
 
 	<link rel="stylesheet" href="../../../skin/tablesort.css" type="text/css"/>
 	<link rel="stylesheet" href="../../../skin/style.css.php" type="text/css">
-	<link rel="stylesheet" type="text/css" href="../../../skin/jquery-ui-1.9.2.custom.min.css">
+	<link rel="stylesheet" type="text/css" href="../../../skin/jquery-ui-1.9.2.custom.min.css">
-<script type="text/javascript" src="../../../vendor/jquery/jquery1/jquery-1.12.4.min.js"></script>
+	<script type="text/javascript" src="../../../vendor/jquery/jquery1/jquery-1.12.4.min.js"></script>
-<script type="text/javascript" src="../../../vendor/christianbach/tablesorter/jquery.tablesorter.min.js"></script>
+	<script type="text/javascript" src="../../../vendor/christianbach/tablesorter/jquery.tablesorter.min.js"></script>
-<script type="text/javascript" src="../../../vendor/components/jqueryui/jquery-ui.min.js"></script>
+	<script type="text/javascript" src="../../../vendor/components/jqueryui/jquery-ui.min.js"></script>
-<script type="text/javascript" src="../../../include/js/jquery.ui.datepicker.translation.js"></script>
+	<script type="text/javascript" src="../../../include/js/jquery.ui.datepicker.translation.js"></script>
-<script type="text/javascript" src="../../../vendor/jquery/sizzle/sizzle.js"></script>';
+	<script type="text/javascript" src="../../../vendor/jquery/sizzle/sizzle.js"></script>';
+
+const MOODLE_ADDON_KURZBZ = 'moodle';
 
 // Load Addons to get Moodle_Path
 $addon_obj = new addon();
-if ($addon_obj->loadAddons())
+
+// include moodle addon config if active
+if ($addon_obj->checkActiveAddon(MOODLE_ADDON_KURZBZ) && file_exists('../../../addons/'.MOODLE_ADDON_KURZBZ.'/config.inc.php'))
 {
-	if (count($addon_obj->result) > 0)
+	include_once('../../../addons/'.MOODLE_ADDON_KURZBZ.'/config.inc.php');
-	{
-		foreach ($addon_obj->result as $row)
-		{
-			if (file_exists('../../../addons/'.$row->kurzbz.'/config.inc.php'))
-				include_once('../../../addons/'.$row->kurzbz.'/config.inc.php');
-		}
-	}
 }
 
 echo '
@@ -117,6 +114,7 @@ echo '</SELECT>
 <input type="submit" value="'.$p->t("services/filtern").'" />
 </form>';
 
+$servicekategorie_arr = $service->getKategorieArray();
 
 if($oe_kurzbz!='')
 {
@@ -134,6 +132,7 @@ echo '<table class="tablesorter" id="myTable">
 			<th>'.$p->t("global/bezeichnung").'</th>
 			<th>'.$p->t("services/leistung").'</th>
 			<th>'.$p->t("services/design").'</th>
+			<th>'.$p->t("services/kritikalitaet").'</th>
 			<th>'.$p->t("services/details").'</th>
 		</tr>
 	</thead>
@@ -159,6 +158,8 @@ foreach($service->result as $row)
 		echo '<td><nobr><a href="../profile/index.php?uid='.$row->design_uid.'">',$design,'</a></nobr></td>';
 		//echo '<td><nobr><a href="../profile/index.php?uid='.$row->betrieb_uid.'">',$betrieb,'</a></nobr></td>';
 		//echo '<td><nobr><a href="../profile/index.php?uid='.$row->operativ_uid.'">',$operativ,'</a></nobr></td>';
+		$title = (isset($servicekategorie_arr[$row->servicekategorie_kurzbz])?$servicekategorie_arr[$row->servicekategorie_kurzbz]:'');
+		echo '<td><span title="'.$service->convert_html_chars($title).'">',$title,'</span></td>';
 		echo '<td>'.($row->content_id!=''?'<a href="../../../cms/content.php?content_id='.$row->content_id.'">Details</a>':'');
 		if (defined("ADDON_MOODLE_PATH"))
 			echo ' '.($row->ext_id!=''?'<a href="'.ADDON_MOODLE_PATH.'course/view.php?id='.$row->ext_id.'" target="_blank">Beschreibung</a>':'');

cis/private/lehre/anwesenheitsliste.php

@@ -62,7 +62,7 @@
     	$stsem = $_GET['stsem'];
     else
     	die($p->t('anwesenheitsliste/studiensemesterIstUngueltig'));
-	
+
 $covidhelper = new CovidHelper();
 ?>
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
@@ -114,9 +114,6 @@ $covidhelper = new CovidHelper();
 
 	  	echo "</table>";
 
-	  	$qry = "SELECT *, tbl_lehreinheitgruppe.studiengang_kz, tbl_lehreinheitgruppe.semester FROM lehre.tbl_lehreinheit JOIN lehre.tbl_lehreinheitgruppe USING(lehreinheit_id) JOIN lehre.tbl_lehrveranstaltung USING(lehrveranstaltung_id)
-	  			WHERE lehrveranstaltung_id='$lvid' AND studiensemester_kurzbz=".$db->db_add_param($stsem);
-
 	  	$qry = "SELECT *, tbl_lehreinheitgruppe.studiengang_kz, tbl_lehreinheitgruppe.semester ,tbl_lehreinheit.lehrform_kurzbz
 				 FROM lehre.tbl_lehreinheit
 				JOIN lehre.tbl_lehreinheitgruppe USING(lehreinheit_id)
@@ -213,7 +210,7 @@ $covidhelper = new CovidHelper();
 				$covid_content = "<table border='0' cellspacing='0'><tr><td><h3>".$p->t('anwesenheitsliste/covidstatuslisten')."</h3></td></tr>".$covid_content."</table>";
 		  	else
 		  		$covid_content = ($covidhelper->isUdfDefined()) ? $p->t('anwesenheitsliste/keineStudentenVorhanden') : '';
-			
+
 		  	if($aw_content!='')
 				$aw_content = "<table border='0' cellspacing='0'><tr><td><h3>".$p->t('anwesenheitsliste/anwesenheitslisten')."</h3></td></tr>".$aw_content."</table>";
 		  	else
@@ -241,9 +238,9 @@ $covidhelper = new CovidHelper();
 			{
 				$covid_content = '';
 			}
-			
+
 		  	echo "<table cellpadding='0' cellspacing='0'>
-				
+
 		  		<tr>
 		  		   <td>$aw_content</td>
 				   <td class=\"covidstatus\">$covid_content</td>

cis/private/lehre/benotungstool/lvgesamtnoteverwalten.php

@@ -102,6 +102,22 @@ $noten_obj->getAll();
 $sprachen = new sprache();
 $sprachen->getAll(true);
 
+
+$noten_array = array();
+$js_noten='';
+foreach ($noten_obj->result as $row)
+{
+	$js_noten .= "	noten_array['" . $row->note . "']='" . addslashes($row->bezeichnung) . "';\n";
+	$noten_array[$row->note]['bezeichnung'] = $row->bezeichnung;
+	$noten_array[$row->note]['positiv'] = $row->positiv;
+	$noten_array[$row->note]['aktiv'] = $row->aktiv;
+	$noten_array[$row->note]['lehre'] = $row->lehre;
+	$noten_array[$row->note]['lkt_ueberschreibbar'] = $row->lkt_ueberschreibbar;
+	$noten_array[$row->note]['anmerkung'] = $row->anmerkung;
+	foreach ($sprachen->result as $s)
+		$noten_array[$row->note]['bezeichnung_mehrsprachig'][$s->sprache] = $row->bezeichnung_mehrsprachig[$s->sprache];
+}
+
 $errormsg = '';
 
 // eingetragene lv-gesamtnoten freigeben
@@ -326,19 +342,7 @@ echo '<!DOCTYPE HTML>
 	var noten_array = Array();
 ';
 
-$noten_array = array();
+echo $js_noten;
-foreach ($noten_obj->result as $row)
-{
-	echo "	noten_array['" . $row->note . "']='" . addslashes($row->bezeichnung) . "';\n";
-	$noten_array[$row->note]['bezeichnung'] = $row->bezeichnung;
-	$noten_array[$row->note]['positiv'] = $row->positiv;
-	$noten_array[$row->note]['aktiv'] = $row->aktiv;
-	$noten_array[$row->note]['lehre'] = $row->lehre;
-	$noten_array[$row->note]['lkt_ueberschreibbar'] = $row->lkt_ueberschreibbar;
-	$noten_array[$row->note]['anmerkung'] = $row->anmerkung;
-	foreach ($sprachen->result as $s)
-		$noten_array[$row->note]['bezeichnung_mehrsprachig'][$s->sprache] = $row->bezeichnung_mehrsprachig[$s->sprache];
-}
 
 ?>
 
@@ -806,16 +810,16 @@ foreach ($noten_obj->result as $row)
 		for(row in rows)
 		{
 			linenumber++;
-			if( rows[row] == '' ) 
+			if( rows[row] == '' )
 			{
 				//skip empty lines
 				continue;
 			}
 			zeile = rows[row].split("	");
-			
+
 			if( zeile.length < 2 )
 			{
-			  alertMsg = alertMsg + "Zeile " + linenumber + ': ' 
+			  alertMsg = alertMsg + "Zeile " + linenumber + ': '
 			  + 'Zu wenig Paramter - 2 erforderlich.  '
 			  + 'Die Zeile wurde uebersprungen.' + "\n\n";
 			  continue;
@@ -917,36 +921,36 @@ foreach ($noten_obj->result as $row)
 		for(row in rows)
 		{
 			linenumber++;
-			if( rows[row] == '' ) 
+			if( rows[row] == '' )
 			{
 				//skip empty lines
 				continue;
 			}
 			zeile = rows[row].split("	");
-			
+
 			if( zeile.length < 3 )
 			{
-			  alertMsg = alertMsg + "Zeile " + linenumber + ': ' 
+			  alertMsg = alertMsg + "Zeile " + linenumber + ': '
 			  + 'Zu wenig Paramter - 3 erforderlich.  '
 			  + 'Die Zeile wurde uebersprungen.' + "\n\n";
 			  continue;
 			}
-			
+
 			if( zeile[1] == '' && zeile[2] == '' )
 			{
-				// ignore lines just copied from excel 
+				// ignore lines just copied from excel
 				continue;
 			}
-			
+
-			if( zeile[2] == '' ) 
+			if( zeile[2] == '' )
 			{
 				alertMsg = alertMsg + "Zeile " + linenumber + ': '
 					+ "Die Note oder Punkte fehlen. "
 					+ "Die Zeile wurde uebersprungen. \n\n";
-				continue;			
+				continue;
 			}
-			
+
-			if (CIS_GESAMTNOTE_PUNKTE == false) 
+			if (CIS_GESAMTNOTE_PUNKTE == false)
 			{
 				// check for valid grades
 				if (validGrades.indexOf(zeile[2]) === -1)
@@ -958,7 +962,7 @@ foreach ($noten_obj->result as $row)
 				}
 			}
 
-			if( !zeile[1].match(/[0-9]{2}\.[0-9]{2}\.[0-9]{4}/)  ) 
+			if( !zeile[1].match(/[0-9]{2}\.[0-9]{2}\.[0-9]{4}/)  )
 			{
 				alertMsg = alertMsg + "Zeile " + linenumber + ': '
 					+ "Das Datum "+zeile[1]+" fehlt oder ist nicht zulaessig. "

cis/private/lehre/benotungstool/nachpruefungeintragen.php

@@ -251,7 +251,7 @@ else
 		// deshalb wird hier versucht eine passende Lehreinheit zu ermitteln.
 		$lehreinheit_id = getLehreinheit($db, $lvid, $student_uid, $stsem);
 
-		$response = savePruefung($lvid, $student_uid, $stsem, $lehreinheit_id, $datum, $typ, $note);
+		$response = savePruefung($lvid, $student_uid, $stsem, $lehreinheit_id, $datum, $typ, $note, $punkte);
 		echo $response;
 	}
 	else

cis/private/lvplan/stpl_week.php

@@ -270,7 +270,7 @@ if (isset($_POST['titel']))
 	foreach($addon_obj->result as $addon)
 	{
 		if(file_exists('../../../addons/'.$addon->kurzbz.'/cis/init.js.php'))
-			echo '<script type="application/x-javascript" src="../../../addons/'.$addon->kurzbz.'/cis/init.js.php" ></script>';
+			echo '<script type="application/x-javascript" src="../../../addons/'.$addon->kurzbz.'/cis/init.js.php"></script>';
 	}
 
 	// Wenn Seite fertig geladen ist Addons aufrufen

cis/private/pdfExport.php

@@ -65,6 +65,11 @@ $xsl_stg_kz = 0;
 
 $sign = false;
 
+/* Signing on CIS disabled
+if(isset($_GET['sign']))
+	$sign = true;
+*/
+
 // Direkte uebergabe des Studienganges dessen Vorlage verwendet werden soll
 if (isset($_GET['xsl_stg_kz']))
 	$xsl_stg_kz = $_GET['xsl_stg_kz'];
@@ -298,22 +303,18 @@ if ((((isset($_GET["uid"]) && $user == $_GET["uid"])) || $rechte->isBerechtigt('
 
 	$dokument->setFilename($filename);
 
-	if (!$dokument->create($output))
-		die($dokument->errormsg);
-
 	if ($sign === true)
 	{
-		if ($dokument->sign($user))
+		if (!$dokument->sign($user))
-		{
-			$dokument->output();
-		}
-		else
 		{
 			echo $dokument->errormsg;
 		}
 	}
-	else
+
-		$dokument->output();
+	if (!$dokument->create($output))
+		die($dokument->errormsg);
+
+	$dokument->output();
 	$dokument->close();
 }
 else

cis/private/tools/zeitaufzeichnung.php

@@ -1222,7 +1222,6 @@ if ($projekt->getProjekteMitarbeiter($user, true))
 				<td colspan="4"><SELECT name="projekt" id="projekt">
 					<OPTION value="">-- '.$p->t('zeitaufzeichnung/keineAuswahl').' --</OPTION>';
 
-			sort($projekt->result);
 			$projektfound = false;
 			foreach ($projekt->result as $row_projekt)
 			{
@@ -1976,7 +1975,6 @@ function getDataForProjectOverviewCSV($user)
 		}
 	}
 
-	sort($csvData);
 	//headers schreiben
 	$header = array('PROJEKT', 'PROJEKT KURZBEZEICHNUNG', 'PROJEKTPHASE', 'PROJEKTPHASEN ID', 'START', 'PROJEKT ENDE');
 

cis/private/tools/zeitaufzeichnung_projektliste.php

@@ -60,7 +60,7 @@ if (isset($_GET['uid']))
 	$rechte = new benutzerberechtigung();
 	$rechte->getBerechtigungen($uid);
 
-	if ($rechte->isBerechtigt('admin') || (in_array($_GET['uid'], $untergebenen_arr)))
+	if ($rechte->isBerechtigt('admin') || $rechte->isBerechtigt('mitarbeiter/zeitsperre') || (in_array($_GET['uid'], $untergebenen_arr)))
 	{
 		$uid = $_GET['uid'];
 	}

content/lvplanung/lehrveranstaltungnotenoverlay.xul.php

@@ -122,7 +122,7 @@ echo "<?xml-stylesheet href=\"".APP_ROOT."content/bindings.css\" type=\"text/css
 			<splitter class="tree-splitter"/>
 			<treecol id="lehrveranstaltung-noten-tree-verband" label="Verband" flex="2" hidden="true" persist="hidden, width, ordinal"
 				class="sortDirectionIndicator"
-				sort="rdf:http://www.technikum-wien.at/zeugnisnote/rdf#verband" />						
+				sort="rdf:http://www.technikum-wien.at/zeugnisnote/rdf#verband" />
             <splitter class="tree-splitter"/>
             <treecol id="lehrveranstaltung-noten-tree-studiengang_kz_lv" label="LehrveranstaltungStudiengang_kz" flex="1" hidden="true" persist="hidden, width, ordinal"
                      class="sortDirectionIndicator"
@@ -299,7 +299,7 @@ if(defined('FAS_GESAMTNOTE_PRUEFUNGSHONORAR') && FAS_GESAMTNOTE_PRUEFUNGSHONORAR
 		<hbox>
 			<label value="MitarbeiterIn" control="lehrveranstaltung-noten-pruefung-menulist-mitarbeiter"/>
 			<menulist id="lehrveranstaltung-noten-pruefung-menulist-mitarbeiter"
-				      datasources="'.APP_ROOT.'rdf/mitarbeiter.rdf.php" flex="1"
+				      datasources="'.APP_ROOT.'rdf/mitarbeiter.rdf.php?aktiv=true" flex="1"
 				      ref="http://www.technikum-wien.at/mitarbeiter/_alle"
 		              minwidth="250"
 				      >

content/statistik/lehrauftragsliste_mail.xls.php

@@ -30,6 +30,8 @@ require_once('../../include/Excel/excel.php');
 require_once('../../include/studiengang.class.php');
 require_once('../../include/studiensemester.class.php');
 require_once('../../include/mail.class.php');
+require_once('../../include/benutzerfunktion.class.php');
+require_once('../../include/organisationseinheit.class.php');
 
 $stsem = new studiensemester();
 
@@ -96,12 +98,11 @@ $qry_stg = "SELECT distinct studiengang_kz, typ, kurzbz
 				SELECT
 					studiengang_kz
 				FROM
-					lehre.tbl_projektbetreuer, lehre.tbl_projektarbeit, lehre.tbl_lehreinheit, lehre.tbl_lehrveranstaltung
+					lehre.tbl_projektbetreuer JOIN lehre.tbl_projektarbeit ON tbl_projektbetreuer.projektarbeit_id=tbl_projektarbeit.projektarbeit_id
+					JOIN lehre.tbl_lehreinheit ON tbl_lehreinheit.lehreinheit_id = tbl_projektarbeit.lehreinheit_id
+					JOIN lehre.tbl_lehrveranstaltung ON tbl_lehrveranstaltung.lehrveranstaltung_id = tbl_lehreinheit.lehrveranstaltung_id
 				WHERE
-					lehre.tbl_lehreinheit.studiensemester_kurzbz=".$db->db_add_param($semester_aktuell)." AND
+					lehre.tbl_lehreinheit.studiensemester_kurzbz=".$db->db_add_param($semester_aktuell)."
-					tbl_projektbetreuer.projektarbeit_id=tbl_projektarbeit.projektarbeit_id AND
-					tbl_projektarbeit.lehreinheit_id = tbl_lehreinheit.lehreinheit_id AND
-					tbl_lehreinheit.lehrveranstaltung_id = tbl_lehrveranstaltung.lehrveranstaltung_id
 				) as foo
 				JOIN public.tbl_studiengang USING (studiengang_kz)
 				";
@@ -124,6 +125,10 @@ $workbook->setCustomColor(10, 255, 186, 179);
 $format_colored =& $workbook->addFormat();
 $format_colored->setFgColor(10);
 
+$workbook->setCustomColor(10, 238, 238, 0);
+$oe_colored =& $workbook->addFormat();
+$oe_colored->setFgColor(11);
+
 $format_number_colored =& $workbook->addFormat();
 $format_number_colored->setNumFormat('0,0.00');
 //$format_number_colored->setNumFormat('0.00');
@@ -185,6 +190,17 @@ if ($result_stg = $db->db_query($qry_stg))
 		$gesamt->write($gesamtsheet_row, $i, "Gesamtstunden", $format_bold);
 		$worksheet->write(2, ++$i, "Gesamtkosten", $format_bold);
 		$gesamt->write($gesamtsheet_row, $i, "Gesamtkosten", $format_bold);
+		
+		$worksheet->write(2, ++$i, "Gesamtstunden bestellt", $format_bold);
+		$gesamt->write($gesamtsheet_row, $i, "Gesamtstunden bestellt", $format_bold);
+		$worksheet->write(2, ++$i, "Gesamtkosten bestellt", $format_bold);
+		$gesamt->write($gesamtsheet_row, $i, "Gesamtkosten bestellt", $format_bold);
+		
+		$worksheet->write(2, ++$i, "Gesamtstunden erteilt", $format_bold);
+		$gesamt->write($gesamtsheet_row, $i, "Gesamtstunden erteilt", $format_bold);
+		$worksheet->write(2, ++$i, "Gesamtkosten erteilt", $format_bold);
+		$gesamt->write($gesamtsheet_row, $i, "Gesamtkosten erteilt", $format_bold);
+
 		$worksheet->write(2, ++$i, "Gesamtstunden angenommen", $format_bold);
 		$gesamt->write($gesamtsheet_row, $i, "Gesamtstunden angenommen", $format_bold);
 		$worksheet->write(2, ++$i, "Gesamtkosten angenommen", $format_bold);
@@ -209,7 +225,7 @@ if ($result_stg = $db->db_query($qry_stg))
 						SELECT tbl_organisationseinheit.organisationseinheittyp_kurzbz || ' ' || tbl_organisationseinheit.bezeichnung
 						FROM PUBLIC.tbl_benutzerfunktion
 						JOIN PUBLIC.tbl_organisationseinheit USING (oe_kurzbz)
-						WHERE funktion_kurzbz = 'oezuordnung'
+						WHERE funktion_kurzbz = (CASE WHEN fixangestellt = true THEN 'kstzuordnung' ELSE 'oezuordnung' END)
 							AND (
 								datum_von IS NULL
 								OR datum_von <= now()
@@ -229,7 +245,7 @@ if ($result_stg = $db->db_query($qry_stg))
 								WHERE oe_kurzbz IN (
 										SELECT oe_kurzbz
 										FROM PUBLIC.tbl_benutzerfunktion
-										WHERE funktion_kurzbz = 'oezuordnung'
+										WHERE funktion_kurzbz = (CASE WHEN fixangestellt = true THEN 'kstzuordnung' ELSE 'oezuordnung' END)
 											AND (
 												datum_von IS NULL
 												OR datum_von <= now()
@@ -262,26 +278,20 @@ if ($result_stg = $db->db_query($qry_stg))
 							THEN 't'
 						ELSE 'f'
 						END AS geaendert,
-					(SELECT
+					 (SELECT
-						vertragsstatus_kurzbz
+							ARRAY_TO_STRING(ARRAY_AGG(vertragsstatus_kurzbz), ',')
-					FROM
+							FROM
-						lehre.tbl_vertrag_vertragsstatus
+								lehre.tbl_vertrag_vertragsstatus
-					WHERE
+							WHERE
-						vertrag_id = tbl_lehreinheitmitarbeiter.vertrag_id
+								vertrag_id = tbl_lehreinheitmitarbeiter.vertrag_id
-					ORDER BY datum DESC
+						) as vertragsstatus
-					LIMIT 1) as vertragsstatus
+				FROM lehre.tbl_lehreinheit
-				FROM lehre.tbl_lehreinheit,
+				    JOIN lehre.tbl_lehreinheitmitarbeiter ON tbl_lehreinheit.lehreinheit_id = tbl_lehreinheitmitarbeiter.lehreinheit_id
-					lehre.tbl_lehreinheitmitarbeiter,
+				    JOIN PUBLIC.tbl_mitarbeiter ON tbl_lehreinheitmitarbeiter.mitarbeiter_uid = tbl_mitarbeiter.mitarbeiter_uid
-					PUBLIC.tbl_mitarbeiter,
+					JOIN PUBLIC.tbl_benutzer ON tbl_benutzer.uid = tbl_mitarbeiter.mitarbeiter_uid
-					PUBLIC.tbl_benutzer,
+					JOIN PUBLIC.tbl_person ON tbl_person.person_id = tbl_benutzer.person_id
-					PUBLIC.tbl_person,
+					JOIN lehre.tbl_lehrveranstaltung ON  tbl_lehrveranstaltung.lehrveranstaltung_id = tbl_lehreinheit.lehrveranstaltung_id
-					lehre.tbl_lehrveranstaltung
+				WHERE studiengang_kz = ".$db->db_add_param($studiengang_kz)."
-				WHERE tbl_person.person_id = tbl_benutzer.person_id
-					AND tbl_benutzer.uid = tbl_mitarbeiter.mitarbeiter_uid
-					AND tbl_lehreinheitmitarbeiter.mitarbeiter_uid = tbl_mitarbeiter.mitarbeiter_uid
-					AND tbl_lehreinheit.lehreinheit_id = tbl_lehreinheitmitarbeiter.lehreinheit_id
-					AND tbl_lehrveranstaltung.lehrveranstaltung_id = tbl_lehreinheit.lehrveranstaltung_id
-					AND studiengang_kz = ".$db->db_add_param($studiengang_kz)."
 					AND studiensemester_kurzbz = ".$db->db_add_param($semester_aktuell)."
 					AND tbl_lehreinheitmitarbeiter.semesterstunden <> 0
 					AND tbl_lehreinheitmitarbeiter.semesterstunden IS NOT NULL
@@ -302,6 +312,7 @@ if ($result_stg = $db->db_query($qry_stg))
 			$gesamtsheet_row++;
 			while ($row = $db->db_fetch_object($result))
 			{
+				$row->vertragsstatus = explode(',', $row->vertragsstatus);
 				//Gesamtstunden und Kosten ermitteln
 				if (array_key_exists($row->mitarbeiter_uid, $liste))
 				{
@@ -314,13 +325,43 @@ if ($result_stg = $db->db_query($qry_stg))
 					$liste[$row->mitarbeiter_uid]['gesamtkosten'] =
 						$liste[$row->mitarbeiter_uid]['gesamtkosten'] + ($row->semesterstunden * $row->stundensatz);
 
+					if (!isset($liste[$row->mitarbeiter_uid]['gesamtstunden_bestellt']))
+					{
+						$liste[$row->mitarbeiter_uid]['gesamtstunden_bestellt'] = 0;
+						$liste[$row->mitarbeiter_uid]['gesamtkosten_bestellt'] = 0;
+					}
+
+					if (!isset($liste[$row->mitarbeiter_uid]['gesamtstunden_erteilt']))
+					{
+						$liste[$row->mitarbeiter_uid]['gesamtstunden_erteilt'] = 0;
+						$liste[$row->mitarbeiter_uid]['gesamtkosten_erteilt'] = 0;
+					}
+
 					if (!isset($liste[$row->mitarbeiter_uid]['gesamtstunden_akzeptiert']))
 					{
 						$liste[$row->mitarbeiter_uid]['gesamtstunden_akzeptiert'] = 0;
 						$liste[$row->mitarbeiter_uid]['gesamtkosten_akzeptiert'] = 0;
 					}
 
-					if ($row->vertragsstatus == 'akzeptiert')
+					if (in_array('bestellt', $row->vertragsstatus))
+					{
+						$liste[$row->mitarbeiter_uid]['gesamtstunden_bestellt'] =
+							$liste[$row->mitarbeiter_uid]['gesamtstunden_bestellt'] + $row->semesterstunden;
+						$liste[$row->mitarbeiter_uid]['gesamtkosten_bestellt'] =
+							$liste[$row->mitarbeiter_uid]['gesamtkosten_bestellt']
+							+ ($row->semesterstunden * $row->stundensatz);
+					}
+
+					if (in_array('erteilt', $row->vertragsstatus))
+					{
+						$liste[$row->mitarbeiter_uid]['gesamtstunden_erteilt'] =
+							$liste[$row->mitarbeiter_uid]['gesamtstunden_erteilt'] + $row->semesterstunden;
+						$liste[$row->mitarbeiter_uid]['gesamtkosten_erteilt'] =
+							$liste[$row->mitarbeiter_uid]['gesamtkosten_erteilt']
+							+ ($row->semesterstunden * $row->stundensatz);
+					}
+
+					if (in_array('akzeptiert', $row->vertragsstatus))
 					{
 						$liste[$row->mitarbeiter_uid]['gesamtstunden_akzeptiert'] =
 							$liste[$row->mitarbeiter_uid]['gesamtstunden_akzeptiert'] + $row->semesterstunden;
@@ -336,13 +377,43 @@ if ($result_stg = $db->db_query($qry_stg))
 					$liste[$row->mitarbeiter_uid]['gesamtstunden'] = $row->semesterstunden;
 					$liste[$row->mitarbeiter_uid]['gesamtkosten'] = $row->semesterstunden * $row->stundensatz;
 
+					if (!isset($liste[$row->mitarbeiter_uid]['gesamtstunden_bestellt']))
+					{
+						$liste[$row->mitarbeiter_uid]['gesamtstunden_bestellt'] = 0;
+						$liste[$row->mitarbeiter_uid]['gesamtkosten_bestellt'] = 0;
+					}
+
+					if (!isset($liste[$row->mitarbeiter_uid]['gesamtstunden_erteilt']))
+					{
+						$liste[$row->mitarbeiter_uid]['gesamtstunden_erteilt'] = 0;
+						$liste[$row->mitarbeiter_uid]['gesamtkosten_erteilt'] = 0;
+					}
+
 					if (!isset($liste[$row->mitarbeiter_uid]['gesamtstunden_akzeptiert']))
 					{
 						$liste[$row->mitarbeiter_uid]['gesamtstunden_akzeptiert'] = 0;
 						$liste[$row->mitarbeiter_uid]['gesamtkosten_akzeptiert'] = 0;
 					}
 
-					if ($row->vertragsstatus == 'akzeptiert')
+					if (in_array('bestellt', $row->vertragsstatus))
+					{
+						$liste[$row->mitarbeiter_uid]['gesamtstunden_bestellt'] =
+							$liste[$row->mitarbeiter_uid]['gesamtstunden_bestellt'] + $row->semesterstunden;
+						$liste[$row->mitarbeiter_uid]['gesamtkosten_bestellt'] =
+							$liste[$row->mitarbeiter_uid]['gesamtkosten_bestellt']
+							+ ($row->semesterstunden * $row->stundensatz);
+					}
+
+					if (in_array('erteilt', $row->vertragsstatus))
+					{
+						$liste[$row->mitarbeiter_uid]['gesamtstunden_erteilt'] =
+							$liste[$row->mitarbeiter_uid]['gesamtstunden_erteilt'] + $row->semesterstunden;
+						$liste[$row->mitarbeiter_uid]['gesamtkosten_erteilt'] =
+							$liste[$row->mitarbeiter_uid]['gesamtkosten_erteilt']
+							+ ($row->semesterstunden * $row->stundensatz);
+					}
+
+					if (in_array('akzeptiert', $row->vertragsstatus))
 					{
 						$liste[$row->mitarbeiter_uid]['gesamtstunden_akzeptiert'] =
 							$liste[$row->mitarbeiter_uid]['gesamtstunden_akzeptiert'] + $row->semesterstunden;
@@ -356,8 +427,20 @@ if ($result_stg = $db->db_query($qry_stg))
 				$liste[$row->mitarbeiter_uid]['vorname'] = $row->vorname;
 				$liste[$row->mitarbeiter_uid]['nachname'] = $row->nachname;
 				$liste[$row->mitarbeiter_uid]['fixangestellt'] = $row->fixangestellt;
-				$liste[$row->mitarbeiter_uid]['oezuordnung'] = $row->oezuordnung;
+
-				$liste[$row->mitarbeiter_uid]['department'] = $row->department;
+				if (is_null($row->oezuordnung))
+				{
+					$oeInfos = getOe($row->mitarbeiter_uid, $row->fixangestellt);
+					$liste[$row->mitarbeiter_uid]['oezuordnung'] = $oeInfos['oezuordnung'];
+					$liste[$row->mitarbeiter_uid]['department'] = $oeInfos['department'];
+					$liste[$row->mitarbeiter_uid]['organisationgeaendert'] = $oeInfos['organisationgeaendert'];
+				}
+				else
+				{
+					$liste[$row->mitarbeiter_uid]['oezuordnung'] = $row->oezuordnung;
+					$liste[$row->mitarbeiter_uid]['department'] = $row->department;
+				}
+
 				$liste[$row->mitarbeiter_uid]['betreuergesamtstunden'] = 0;
 				$liste[$row->mitarbeiter_uid]['betreuergesamtkosten'] = 0;
 				if ($row->geaendert == 't')
@@ -375,7 +458,7 @@ if ($result_stg = $db->db_query($qry_stg))
 							public.tbl_benutzerfunktion
 							JOIN public.tbl_organisationseinheit USING (oe_kurzbz)
 						WHERE
-							funktion_kurzbz='oezuordnung'
+							funktion_kurzbz = (CASE WHEN fixangestellt = true THEN 'kstzuordnung' ELSE 'oezuordnung' END)
 							AND (datum_von IS NULL OR datum_von <= now())
 							AND (datum_bis IS NULL OR datum_bis >= now())
 							AND tbl_benutzerfunktion.uid = tbl_benutzer.uid
@@ -390,7 +473,7 @@ if ($result_stg = $db->db_query($qry_stg))
 								WHERE oe_kurzbz IN (
 										SELECT oe_kurzbz
 										FROM PUBLIC.tbl_benutzerfunktion
-										WHERE funktion_kurzbz = 'oezuordnung'
+										WHERE funktion_kurzbz = (CASE WHEN fixangestellt = true THEN 'kstzuordnung' ELSE 'oezuordnung' END)
 											AND (
 												datum_von IS NULL
 												OR datum_von <= now()
@@ -419,27 +502,23 @@ if ($result_stg = $db->db_query($qry_stg))
 						WHERE meine_oes.organisationseinheittyp_kurzbz = 'Department'
 						) AS department
 					FROM
-						lehre.tbl_projektbetreuer, public.tbl_person, public.tbl_benutzer,
+						lehre.tbl_projektbetreuer JOIN public.tbl_person ON tbl_projektbetreuer.person_id=tbl_person.person_id
-						public.tbl_mitarbeiter, lehre.tbl_projektarbeit, lehre.tbl_lehreinheit,
+						JOIN public.tbl_benutzer ON tbl_benutzer.person_id=tbl_person.person_id
-						lehre.tbl_lehrveranstaltung
+						JOIN public.tbl_mitarbeiter ON tbl_mitarbeiter.mitarbeiter_uid=tbl_benutzer.uid
+						JOIN lehre.tbl_projektarbeit ON tbl_projektarbeit.projektarbeit_id=tbl_projektbetreuer.projektarbeit_id
+						JOIN lehre.tbl_lehreinheit ON tbl_lehreinheit.lehreinheit_id=tbl_projektarbeit.lehreinheit_id
+						JOIN lehre.tbl_lehrveranstaltung ON tbl_lehrveranstaltung.lehrveranstaltung_id = tbl_lehreinheit.lehrveranstaltung_id
 					WHERE
-						tbl_projektbetreuer.person_id=tbl_person.person_id AND
-						tbl_person.person_id=tbl_benutzer.person_id AND
-						tbl_mitarbeiter.mitarbeiter_uid=tbl_benutzer.uid AND
-						tbl_projektarbeit.projektarbeit_id=tbl_projektbetreuer.projektarbeit_id AND
-						tbl_projektarbeit.lehreinheit_id=tbl_lehreinheit.lehreinheit_id AND
 						tbl_lehreinheit.studiensemester_kurzbz=".$db->db_add_param($semester_aktuell)." AND
-						tbl_lehreinheit.lehrveranstaltung_id = tbl_lehrveranstaltung.lehrveranstaltung_id AND
 						tbl_lehrveranstaltung.studiengang_kz=".$db->db_add_param($studiengang_kz, FHC_INTEGER)." AND
 						NOT EXISTS (SELECT
 										mitarbeiter_uid
 									FROM
-										lehre.tbl_lehreinheitmitarbeiter, lehre.tbl_lehreinheit, lehre.tbl_lehrveranstaltung
+										lehre.tbl_lehreinheitmitarbeiter JOIN lehre.tbl_lehreinheit ON tbl_lehreinheitmitarbeiter.lehreinheit_id=tbl_lehreinheit.lehreinheit_id
+										JOIN lehre.tbl_lehrveranstaltung ON tbl_lehrveranstaltung.lehrveranstaltung_id=tbl_lehreinheit.lehrveranstaltung_id
 									WHERE
 										mitarbeiter_uid=tbl_benutzer.uid AND
-										tbl_lehrveranstaltung.lehrveranstaltung_id=tbl_lehreinheit.lehrveranstaltung_id AND
 										tbl_lehrveranstaltung.studiengang_kz=".$db->db_add_param($studiengang_kz, FHC_INTEGER)." AND
-										tbl_lehreinheitmitarbeiter.lehreinheit_id=tbl_lehreinheit.lehreinheit_id AND
 										tbl_lehreinheitmitarbeiter.semesterstunden<>0 AND
 										tbl_lehreinheitmitarbeiter.semesterstunden is not null AND
 										EXISTS (
@@ -461,8 +540,20 @@ if ($result_stg = $db->db_query($qry_stg))
 						$liste[$row->uid]['vorname'] = $row->vorname;
 						$liste[$row->uid]['nachname'] = $row->nachname;
 						$liste[$row->uid]['fixangestellt'] = $row->fixangestellt;
-						$liste[$row->uid]['oezuordnung'] = $row->oezuordnung;
+
-						$liste[$row->uid]['department'] = $row->department;
+						if (is_null($row->oezuordnung))
+						{
+							$oeInfos = getOe($row->uid, $row->fixangestellt);
+							$liste[$row->uid]['oezuordnung'] = $oeInfos['oezuordnung'];
+							$liste[$row->uid]['department'] = $oeInfos['department'];
+							$liste[$row->uid]['organisationgeaendert'] = $oeInfos['organisationgeaendert'];
+						}
+						else
+						{
+							$liste[$row->uid]['oezuordnung'] = $row->oezuordnung;
+							$liste[$row->uid]['department'] = $row->department;
+						}
+
 						$liste[$row->uid]['geaendert'] = false;
 						$liste[$row->uid]['gesamtstunden'] = 0;
 						$liste[$row->uid]['gesamtkosten'] = 0;
@@ -488,32 +579,29 @@ if ($result_stg = $db->db_query($qry_stg))
 							ELSE
 								'f'
 						END as geaendert,
-						(
+						(SELECT
-							SELECT
+							ARRAY_TO_STRING(ARRAY_AGG(vertragsstatus_kurzbz), ',')
-							vertragsstatus_kurzbz
 							FROM
 								lehre.tbl_vertrag_vertragsstatus
 							WHERE
 								vertrag_id = tbl_projektbetreuer.vertrag_id
-							ORDER BY datum DESC
-							LIMIT 1
 						) as vertragsstatus
-					FROM lehre.tbl_projektbetreuer, lehre.tbl_lehreinheit, lehre.tbl_lehrveranstaltung,
+					FROM
-						public.tbl_benutzer, lehre.tbl_projektarbeit, campus.vw_student
+						lehre.tbl_projektbetreuer JOIN public.tbl_benutzer ON tbl_projektbetreuer.person_id = tbl_benutzer.person_id
+						JOIN lehre.tbl_projektarbeit ON tbl_projektarbeit.projektarbeit_id = tbl_projektbetreuer.projektarbeit_id
+						JOIN lehre.tbl_lehreinheit ON tbl_lehreinheit.lehreinheit_id = tbl_projektarbeit.lehreinheit_id
+						JOIN lehre.tbl_lehrveranstaltung ON tbl_lehreinheit.lehrveranstaltung_id = tbl_lehrveranstaltung.lehrveranstaltung_id
+						JOIN campus.vw_student ON vw_student.uid = student_uid
 					WHERE
-						tbl_projektbetreuer.person_id = tbl_benutzer.person_id
+						tbl_benutzer.uid = ".$db->db_add_param($uid)."
-						AND tbl_benutzer.uid = ".$db->db_add_param($uid)."
-						AND tbl_projektarbeit.projektarbeit_id = tbl_projektbetreuer.projektarbeit_id
-						AND student_uid = vw_student.uid
-						AND tbl_lehreinheit.lehreinheit_id = tbl_projektarbeit.lehreinheit_id
 						AND tbl_lehreinheit.studiensemester_kurzbz=".$db->db_add_param($semester_aktuell)."
-						AND tbl_lehreinheit.lehrveranstaltung_id = tbl_lehrveranstaltung.lehrveranstaltung_id
 						AND tbl_lehrveranstaltung.studiengang_kz=".$db->db_add_param($studiengang_kz, FHC_INTEGER);
 
 				if ($result = $db->db_query($qry))
 				{
 					while ($row = $db->db_fetch_object($result))
 					{
+						$row->vertragsstatus = explode(',', $row->vertragsstatus);
 						$liste[$uid]['gesamtstunden'] = $liste[$uid]['gesamtstunden'] + $row->stunden;
 						$liste[$uid]['gesamtkosten'] =
 							$liste[$uid]['gesamtkosten'] + ($row->stunden * $row->stundensatz);
@@ -524,13 +612,42 @@ if ($result_stg = $db->db_query($qry_stg))
 						{
 							$liste[$uid]['geaendert'] = true;
 						}
+
+						if (!isset($liste[$uid]['gesamtstunden_bestellt']))
+						{
+							$liste[$uid]['gesamtstunden_bestellt'] = 0;
+							$liste[$uid]['gesamtkosten_bestellt'] = 0;
+						}
+
+						if (!isset($liste[$uid]['gesamtstunden_erteilt']))
+						{
+							$liste[$uid]['gesamtstunden_erteilt'] = 0;
+							$liste[$uid]['gesamtkosten_erteilt'] = 0;
+						}
+
 						if (!isset($liste[$uid]['gesamtstunden_akzeptiert']))
 						{
 							$liste[$uid]['gesamtstunden_akzeptiert'] = 0;
 							$liste[$uid]['gesamtkosten_akzeptiert'] = 0;
 						}
 
-						if ($row->vertragsstatus == 'akzeptiert')
+						if (in_array('bestellt', $row->vertragsstatus))
+						{
+							$liste[$uid]['gesamtstunden_bestellt'] =
+								$liste[$uid]['gesamtstunden_bestellt'] + $row->stunden;
+							$liste[$uid]['gesamtkosten_bestellt'] =
+								$liste[$uid]['gesamtkosten_bestellt'] + ($row->stunden * $row->stundensatz);
+						}
+
+						if (in_array('erteilt', $row->vertragsstatus))
+						{
+							$liste[$uid]['gesamtstunden_erteilt'] =
+								$liste[$uid]['gesamtstunden_erteilt'] + $row->stunden;
+							$liste[$uid]['gesamtkosten_erteilt'] =
+								$liste[$uid]['gesamtkosten_erteilt'] + ($row->stunden * $row->stundensatz);
+						}
+
+						if (in_array('akzeptiert', $row->vertragsstatus))
 						{
 							$liste[$uid]['gesamtstunden_akzeptiert'] =
 								$liste[$uid]['gesamtstunden_akzeptiert'] + $row->stunden;
@@ -558,13 +675,20 @@ if ($result_stg = $db->db_query($qry_stg))
 				if (isset($row['geaendert']) && $row['geaendert'] == true)
 				{
 					$format = $format_colored;
+					$formatOE = $format_colored;
 					$formatnb = $format_number_colored;
 				}
 				else
 				{
 					$format = $format_normal;
+					$formatOE = $format_normal;
 					$formatnb = $format_number;
 				}
+
+				if(isset($row['organisationgeaendert']) && $row['organisationgeaendert'] === true)
+				{
+					$formatOE = $oe_colored;
+				}
 				//Studiengang
 				$worksheet->write($zeile, $i, $studiengang->kuerzel, $format);
 				$gesamt->write($gesamtsheet_row, $i, $studiengang->kuerzel, $format);
@@ -584,11 +708,11 @@ if ($result_stg = $db->db_query($qry_stg))
 				$worksheet->write($zeile, ++$i, $row['fixangestellt'], $format);
 				$gesamt->write($gesamtsheet_row, $i, $row['fixangestellt'], $format);
 				//OE-Zuordnung
-				$worksheet->write($zeile, ++$i, $row['oezuordnung'], $format);
+				$worksheet->write($zeile, ++$i, $row['oezuordnung'], $formatOE);
-				$gesamt->write($gesamtsheet_row, $i, $row['oezuordnung'], $format);
+				$gesamt->write($gesamtsheet_row, $i, $row['oezuordnung'], $formatOE);
 				//Department der OE-Zuordnung
-				$worksheet->write($zeile, ++$i, $row['department'], $format);
+				$worksheet->write($zeile, ++$i, $row['department'], $formatOE);
-				$gesamt->write($gesamtsheet_row, $i, $row['department'], $format);
+				$gesamt->write($gesamtsheet_row, $i, $row['department'], $formatOE);
 				//LVStunden
 				$lvstunden = str_replace(', ', '.', $row['lvstunden']);
 				$worksheet->write($zeile, ++$i, $lvstunden, $format);
@@ -613,6 +737,25 @@ if ($result_stg = $db->db_query($qry_stg))
 				$gesamtkosten_row = str_replace(', ', '.', $row['gesamtkosten']);
 				$worksheet->writeNumber($zeile, ++$i, $gesamtkosten_row, $formatnb);
 				$gesamt->writeNumber($gesamtsheet_row, $i, $gesamtkosten_row, $formatnb);
+				
+				//Gesamtstunden bestellt
+				$gesamtstunden_bestellt = str_replace(', ', '.', $row['gesamtstunden_bestellt']);
+				$worksheet->write($zeile, ++$i, $gesamtstunden_bestellt, $formatnb);
+				$gesamt->write($gesamtsheet_row, $i, $gesamtstunden_bestellt, $formatnb);
+				//Gesamtkosten bestellt
+				$gesamtkosten_bestellt_row = str_replace(', ', '.', $row['gesamtkosten_bestellt']);
+				$worksheet->writeNumber($zeile, ++$i, $gesamtkosten_bestellt_row, $formatnb);
+				$gesamt->writeNumber($gesamtsheet_row, $i, $gesamtkosten_bestellt_row, $formatnb);
+				
+				//Gesamtstunden erteilt
+				$gesamtstunden_erteilt = str_replace(', ', '.', $row['gesamtstunden_erteilt']);
+				$worksheet->write($zeile, ++$i, $gesamtstunden_erteilt, $formatnb);
+				$gesamt->write($gesamtsheet_row, $i, $gesamtstunden_erteilt, $formatnb);
+				//Gesamtkosten erteilt
+				$gesamtkosten_erteilt_row = str_replace(', ', '.', $row['gesamtkosten_erteilt']);
+				$worksheet->writeNumber($zeile, ++$i, $gesamtkosten_erteilt_row, $formatnb);
+				$gesamt->writeNumber($gesamtsheet_row, $i, $gesamtkosten_erteilt_row, $formatnb);
+				
 				//Gesamtstunden akzeptiert
 				$gesamtstunden_akzeptiert = str_replace(', ', '.', $row['gesamtstunden_akzeptiert']);
 				$worksheet->write($zeile, ++$i, $gesamtstunden_akzeptiert, $formatnb);
@@ -641,11 +784,31 @@ if ($result_stg = $db->db_query($qry_stg))
 				else
 					$liste_gesamt[$uid]['gesamtkosten'] = $row['gesamtkosten'];
 
+				if (isset($liste_gesamt[$uid]['gesamtstunden_bestellt']))
+					$liste_gesamt[$uid]['gesamtstunden_bestellt'] += $row['gesamtstunden_bestellt'];
+				else
+					$liste_gesamt[$uid]['gesamtstunden_bestellt'] = $row['gesamtstunden_bestellt'];
+				
+				if (isset($liste_gesamt[$uid]['gesamtkosten_bestellt']))
+					$liste_gesamt[$uid]['gesamtkosten_bestellt'] += $row['gesamtkosten_bestellt'];
+				else
+					$liste_gesamt[$uid]['gesamtkosten_bestellt'] = $row['gesamtkosten_bestellt'];
+
+				if (isset($liste_gesamt[$uid]['gesamtstunden_erteilt']))
+					$liste_gesamt[$uid]['gesamtstunden_erteilt'] += $row['gesamtstunden_erteilt'];
+				else
+					$liste_gesamt[$uid]['gesamtstunden_erteilt'] = $row['gesamtstunden_erteilt'];
+				
+				if (isset($liste_gesamt[$uid]['gesamtkosten_erteilt']))
+					$liste_gesamt[$uid]['gesamtkosten_erteilt'] += $row['gesamtkosten_erteilt'];
+				else
+					$liste_gesamt[$uid]['gesamtkosten_erteilt'] = $row['gesamtkosten_erteilt'];
+
 				if (isset($liste_gesamt[$uid]['gesamtstunden_akzeptiert']))
 					$liste_gesamt[$uid]['gesamtstunden_akzeptiert'] += $row['gesamtstunden_akzeptiert'];
 				else
 					$liste_gesamt[$uid]['gesamtstunden_akzeptiert'] = $row['gesamtstunden_akzeptiert'];
-
+				
 				if (isset($liste_gesamt[$uid]['gesamtkosten_akzeptiert']))
 					$liste_gesamt[$uid]['gesamtkosten_akzeptiert'] += $row['gesamtkosten_akzeptiert'];
 				else
@@ -745,3 +908,36 @@ if ($result_stg = $db->db_query($qry_stg))
 	else
 		echo "Fehler beim Versenden der Lehrauftragsliste";
 }
+
+function getOe($mitarbeiter_uid, $fixangestellt)
+{
+	$benutzerfunktion = new Benutzerfunktion();
+	$oe = new Organisationseinheit();
+
+	$benutzerfunktion->getBenutzerFunktionByUid($mitarbeiter_uid, $fixangestellt === 'Ja' ? 'kstzuordnung' : 'oezuordnung', date('Y-m-d'));
+
+	if (isset($benutzerfunktion->result[0]))
+	{
+		array_multisort(array_column($benutzerfunktion->result, 'datum_von'), SORT_ASC, $benutzerfunktion->result);
+	}
+	else
+	{
+		$benutzerfunktion->getBenutzerFunktionByUid($mitarbeiter_uid, $fixangestellt === 'Ja' ? 'kstzuordnung' : 'oezuordnung', null, date('Y-m-d'));
+		array_multisort(array_column($benutzerfunktion->result, 'datum_bis'), SORT_DESC, $benutzerfunktion->result);
+	}
+
+	if (!isset($benutzerfunktion->result[0]))
+		return array('oezuordnung' => '', 'department' => '', 'organisationgeaendert' => false);
+
+	$oe->load($benutzerfunktion->result[0]->oe_kurzbz);
+	$oezuordnung = $oe->organisationseinheittyp_kurzbz . ' ' . $oe->bezeichnung;
+
+	$oe_parents = $oe->getParents_withOEType($oe->oe_kurzbz);
+
+	if (is_array($oe_parents))
+		 $department = ($oe_parents[array_search('Department', array_column($oe_parents, 'oe_typ_bezeichnung'))]->oe_bezeichnung);
+	else
+		$department = '';
+
+	return array('oezuordnung' => $oezuordnung, 'department' => $department, 'organisationgeaendert' => true);
+}

content/student/studentDBDML.php

@@ -74,7 +74,10 @@ require_once('../../include/reihungstest.class.php');
 require_once('../../include/studienplan.class.php');
 require_once('../../include/mobilitaet.class.php');
 require_once('../../include/studienordnung.class.php');
+require_once('../../include/mitarbeiter.class.php');
+require_once('../../include/bisverwendung.class.php');
 require_once('../../include/bismeldestichtag.class.php');
+require_once('../../include/stundensatz.class.php');
 
 $user = get_uid();
 $db = new basis_db();
@@ -4654,6 +4657,7 @@ if(!$error)
 			$errormsg = 'Fehlerhafte Parameteruebergabe';
 		}
 	}
+
 	elseif(isset($_POST['type']) && $_POST['type']=='getstundensatz')
 	{
 		if(isset($_POST['person_id']) && isset($_POST['studiensemester_kurzbz']))
@@ -4661,33 +4665,87 @@ if(!$error)
 			$studiensemester = new studiensemester();
 			if ($studiensemester->load($_POST['studiensemester_kurzbz']))
 			{
-				$qry = "SELECT ss.stundensatz
+				if (defined('FAS_LV_LEKTORINNENZUTEILUNG_FIXANGESTELLT_STUNDENSATZ')
-					FROM hr.tbl_stundensatz ss
+					&& !FAS_LV_LEKTORINNENZUTEILUNG_FIXANGESTELLT_STUNDENSATZ)
-						JOIN public.tbl_mitarbeiter ON ss.uid = tbl_mitarbeiter.mitarbeiter_uid
-						JOIN public.tbl_benutzer ON(tbl_benutzer.uid=tbl_mitarbeiter.mitarbeiter_uid)
-					WHERE person_id=".$db->db_add_param($_POST['person_id'], FHC_INTEGER) ."
-						AND stundensatztyp = ". $db->db_add_param('lehre') ."
-						AND gueltig_von <= ". $db->db_add_param($studiensemester->ende) ."
-						AND (gueltig_bis >= ". $db->db_add_param($studiensemester->start) ." OR gueltig_bis IS NULL)
-					ORDER BY gueltig_bis DESC NULLS FIRST, gueltig_von DESC NULLS LAST LIMIT 1
-					";
-				if($result = $db->db_query($qry))
 				{
-					if($row = $db->db_fetch_object($result))
+					// Mitarbeiter laden
+					$qry = "
+						SELECT
+							mitarbeiter_uid, fixangestellt
+						FROM
+							public.tbl_mitarbeiter
+							JOIN public.tbl_benutzer ON(tbl_benutzer.uid=tbl_mitarbeiter.mitarbeiter_uid)
+						WHERE
+							person_id=".$db->db_add_param($_POST['person_id'], FHC_INTEGER) ."
+						ORDER BY tbl_mitarbeiter.insertamum DESC NULLS LAST LIMIT 1
+						";
+					if($result = $db->db_query($qry))
 					{
-						$data = $row->stundensatz;
+						if($row = $db->db_fetch_object($result))
-						$return = true;
+						{
-					}
+							$uid = $row->mitarbeiter_uid;
-					else
+
-					{
+							if($db->db_parse_bool($row->fixangestellt)==true)
-						$data = '80.00';
+							{
-						$return = true;
+								// Fixangestellte haben keinen Stundensatz
+								$data = '';
+								$return = true;
+							}
+							else
+							{
+								// Stundensatz des Mitarbeiters laden
+								$stundensatz = new stundensatz();
+								if($stundensatz->getStundensatzDatum($uid, $studiensemester->start, $studiensemester->ende, 'lehre'))
+								{
+									$data = $stundensatz->stundensatz;
+									$return = true;
+								}
+								else
+								{
+									// Keine Stundensatz hinterlegt
+									$data = '0.00';
+									$return = true;
+								}
+							}
+						}
+						else
+						{
+							// Kein Mitarbeiter gefunden, kein Stundensatz
+							$data = '0.00';
+							$return = true;
+						}
 					}
 				}
 				else
 				{
-					$return = false;
+					$qry = "SELECT ss.stundensatz
-					$errormsg = 'Unbekannter Fehler';
+						FROM hr.tbl_stundensatz ss
+							JOIN public.tbl_mitarbeiter ON ss.uid = tbl_mitarbeiter.mitarbeiter_uid
+							JOIN public.tbl_benutzer ON(tbl_benutzer.uid=tbl_mitarbeiter.mitarbeiter_uid)
+						WHERE person_id=".$db->db_add_param($_POST['person_id'], FHC_INTEGER) ."
+							AND stundensatztyp = ". $db->db_add_param('lehre') ."
+							AND gueltig_von <= ". $db->db_add_param($studiensemester->ende) ."
+							AND (gueltig_bis >= ". $db->db_add_param($studiensemester->start) ." OR gueltig_bis IS NULL)
+						ORDER BY gueltig_bis DESC NULLS FIRST, gueltig_von DESC NULLS LAST LIMIT 1
+						";
+					if($result = $db->db_query($qry))
+					{
+						if($row = $db->db_fetch_object($result))
+						{
+							$data = $row->stundensatz;
+							$return = true;
+						}
+						else
+						{
+							$data = '80.00';
+							$return = true;
+						}
+					}
+					else
+					{
+						$return = false;
+						$errormsg = 'Unbekannter Fehler';
+					}
 				}
 			}
 			else
@@ -4695,8 +4753,15 @@ if(!$error)
 				$return = false;
 				$errormsg = 'Fehler beim Laden des Studiensemesters';
 			}
+
 		}
-	}
+		else
+		{
+			$data = '20.00'.$_POST['studiensemester_kurzbz'];
+			$return = true;
+		}
+ 	}
+
 	elseif(isset($_POST['type']) && $_POST['type']=='saveanrechnung')
 	{
 		$anrechnung = new anrechnung();

content/student/studentabschlusspruefungoverlay.xul.php

@@ -137,7 +137,7 @@ echo '<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>';
 									<treecell label="rdf:http://www.technikum-wien.at/abschlusspruefung/rdf#pruefer1_nachname" />
 									<treecell label="rdf:http://www.technikum-wien.at/abschlusspruefung/rdf#pruefer2_nachname" />
 									<treecell label="rdf:http://www.technikum-wien.at/abschlusspruefung/rdf#pruefer3_nachname" />
-									<treecell label="rdf:http://www.technikum-wien.at/abschlusspruefung/rdf#abschlussbeurteilung_kurzbz" />
+									<treecell label="rdf:http://www.technikum-wien.at/abschlusspruefung/rdf#abschlussbeurteilung_bezeichnung" />
 									<treecell label="rdf:http://www.technikum-wien.at/abschlusspruefung/rdf#datum" />
 									<treecell label="rdf:http://www.technikum-wien.at/abschlusspruefung/rdf#uhrzeit" />
 									<treecell label="rdf:http://www.technikum-wien.at/abschlusspruefung/rdf#freigabedatum" />

content/student/studentoverlay.js.php

@@ -1658,7 +1658,7 @@ function StudentAuswahl()
 
 		var antragnotentree = document.getElementById('student-antragnoten-tree');
 
-		url='<?php echo APP_ROOT;?>index.ci.php/components/Antrag/Wiederholung/getLvsAsRdf/'+prestudent_id+"?"+gettimestamp();
+		url='<?php echo APP_ROOT;?>index.ci.php/api/frontend/fas/studstatus/Wiederholung/getLvs/'+prestudent_id+"?"+gettimestamp();
 
 		try
 		{
@@ -4764,7 +4764,7 @@ function StudentNotenMoveFromAntrag()
 	var paramList= '';
 	var i = 0;
 
-	var url = '<?php echo APP_ROOT ?>index.ci.php/components/Antrag/Wiederholung/moveLvsToZeugnis';
+	var url = '<?php echo APP_ROOT ?>index.ci.php/api/frontend/fas/studstatus/Wiederholung/moveLvsToZeugnis';
 	var req = new phpRequest(url,'','');
 
 	for (var t = 0; t < numRanges; t++)

content/student/studentprojektarbeit.js.php

@@ -393,6 +393,7 @@ function StudentProjektarbeitAuswahl()
 	anmerkung = getTargetHelper(dsource,subject,rdfService.GetResource( predicateNS + "#anmerkung" ));
 	gesamtstunden = getTargetHelper(dsource,subject,rdfService.GetResource( predicateNS + "#gesamtstunden" ));
 	final = getTargetHelper(dsource,subject,rdfService.GetResource( predicateNS + "#final" ));
+	var lehreinheit_stsem = getTargetHelper(dsource,subject,rdfService.GetResource( predicateNS + "#lehreinheit_stsem" ));
 
 	var stg_kz = document.getElementById('student-detail-menulist-studiengang_kz').value;
 
@@ -440,6 +441,7 @@ function StudentProjektarbeitAuswahl()
 
 	//Werte setzen
 	document.getElementById('student-projektarbeit-textbox-projektarbeit_id').value=projektarbeit_id;
+	document.getElementById('student-projektarbeit-textbox-lehreinheit_stsem').value=lehreinheit_stsem;
 	document.getElementById('student-projektarbeit-menulist-projekttyp').value=projekttyp_kurzbz;
 	document.getElementById('student-projektarbeit-menulist-lehrveranstaltung').value=lehrveranstaltung_id;
 	document.getElementById('student-projektarbeit-menulist-lehreinheit').value=lehreinheit_id;
@@ -649,6 +651,8 @@ function StudentProjektarbeitNeu()
 
 	document.getElementById('student-projektarbeit-checkbox-neu').checked=true;
 	document.getElementById('student-projektarbeit-textbox-projektarbeit_id').value='';
+	document.getElementById('student-projektarbeit-textbox-lehreinheit_stsem').value='';
+
 	StudentProjektarbeitResetFields();
 	StudentProjektarbeitDetailDisableFields(false);
 	StudentProjektbetreuerDisableFields(true);
@@ -872,6 +876,7 @@ function StudentProjektbetreuerAuswahl()
 	name = getTargetHelper(dsource,subject,rdfService.GetResource( predicateNS + "#name" ));
 	punkte = getTargetHelper(dsource,subject,rdfService.GetResource( predicateNS + "#punkte" ));
 	stunden = getTargetHelper(dsource,subject,rdfService.GetResource( predicateNS + "#stunden" ));
+
 	stundensatz = getTargetHelper(dsource,subject,rdfService.GetResource( predicateNS + "#stundensatz" ));
 	betreuerart_kurzbz = getTargetHelper(dsource,subject,rdfService.GetResource( predicateNS + "#betreuerart_kurzbz" ));
 	person_nachname = getTargetHelper(dsource,subject,rdfService.GetResource( predicateNS + "#person_nachname" ));
@@ -892,6 +897,16 @@ function StudentProjektbetreuerAuswahl()
 	document.getElementById('student-projektbetreuer-textbox-person_id').value=person_id;
 	document.getElementById('student-projektbetreuer-checkbox-neu').checked=false;
 
+	var lehreinheitstsem = document.getElementById('student-projektarbeit-textbox-lehreinheit_stsem').value;
+	var default_stundensatz = StudentProjektbetreuerLoadStundensatz(person_id, lehreinheitstsem);
+
+	if (default_stundensatz != '')
+		default_stundensatz = 'Stundensatz (Default '+default_stundensatz+'):';
+	else
+		default_stundensatz = 'Stundensatz';
+
+	document.getElementById('student-projektbetreuer-label-stundensatz').value= default_stundensatz;
+
     var gesamtkosten = StudentProjektbetreuerGesamtkosten();
 
 
@@ -1171,7 +1186,9 @@ function StudentProjektbetreuerDetailReset()
 		document.getElementById('student-projektbetreuer-textbox-stunden').value='0.0';
 		document.getElementById('student-projektbetreuer-menulist-betreuerart').value='Begutachter';
 	}
+
 	document.getElementById('student-projektbetreuer-textbox-stundensatz').value='80.0';
+	document.getElementById('student-projektbetreuer-label-stundensatz').value= 'Stundensatz (Default 80.0):';
 	document.getElementById('student-projektbetreuer-menulist-person').value='';
 }
 
@@ -1358,16 +1375,16 @@ function StudentProjektbetreuerLoeschen()
 	}
 }
 
-function StudentProjektbetreuerLoadMitarbeiterDaten()
+function StudentProjektbetreuerLoadStundensatz(person_id, studiensemester)
 {
-	person_id = MenulistGetSelectedValue('student-projektbetreuer-menulist-person');
+	var stundensatz='';
 
 	var url = '<?php echo APP_ROOT ?>content/student/studentDBDML.php';
 	var req = new phpRequest(url,'','');
 
 	req.add('type', 'getstundensatz');
 	req.add('person_id', person_id);
-	req.add('studiensemester_kurzbz', getStudiensemester())
+	req.add('studiensemester_kurzbz', studiensemester)
 
 	var response = req.executePOST();
 
@@ -1385,7 +1402,23 @@ function StudentProjektbetreuerLoadMitarbeiterDaten()
 		stundensatz = val.dbdml_data
 	}
 
-	document.getElementById('student-projektbetreuer-textbox-stundensatz').value=stundensatz;
+	return stundensatz;
+}
+
+function StudentProjektbetreuerLoadMitarbeiterDaten()
+{
+	var person_id = MenulistGetSelectedValue('student-projektbetreuer-menulist-person');
+	var lehreinheitstsem = document.getElementById('student-projektarbeit-textbox-lehreinheit_stsem').value;
+
+	var stundensatz = StudentProjektbetreuerLoadStundensatz(person_id, lehreinheitstsem);
+
+	if (stundensatz != '')
+		default_stundensatz = 'Stundensatz (Default '+stundensatz+'):';
+	else
+		default_stundensatz = 'Stundensatz';
+
+	document.getElementById('student-projektbetreuer-label-stundensatz').value = default_stundensatz;
+	document.getElementById('student-projektbetreuer-textbox-stundensatz').value = stundensatz;
 }
 
 // ****

content/student/studentprojektarbeitoverlay.xul.php

@@ -171,7 +171,11 @@ $is_hidden = (!defined('FAS_STUDIERENDE_PROJEKTARBEIT_VERTRAGSDETAILS_ANZEIGEN')
 					<rows>
 						<row>
 							<label value="Projektarbeit ID" control="student-projektarbeit-textbox-projektarbeit_id"/>
-							<hbox><textbox id="student-projektarbeit-textbox-projektarbeit_id" readonly="true" maxlength="16" size="16"/></hbox>
+							<hbox>
+								<textbox id="student-projektarbeit-textbox-projektarbeit_id" readonly="true" maxlength="16" size="16"/>
+								<textbox id="student-projektarbeit-textbox-lehreinheit_stsem" hidden="true" readonly="true" maxlength="32" size="32"/>
+							</hbox>
+
 						</row>
 						<row>
 							<label value="Titel" control="student-projektarbeit-textbox-titel"/>
@@ -523,7 +527,7 @@ $is_hidden = (!defined('FAS_STUDIERENDE_PROJEKTARBEIT_VERTRAGSDETAILS_ANZEIGEN')
 								<textbox id="student-projektbetreuer-textbox-stunden" disabled="true" maxlength="8"/>
 							</row>
 							<row>
-								<label value="Stundensatz" control="student-projektbetreuer-textbox-stundensatz"/>
+								<label id="student-projektbetreuer-label-stundensatz" value="Stundensatz: " control="student-projektbetreuer-textbox-stundensatz"/>
 								<textbox id="student-projektbetreuer-textbox-stundensatz" disabled="true" maxlength="5"/>
 							</row>
 							<row hidden="true"><!-- Faktor wird nicht mehr benoetigt -->

include/mitarbeiter.class.php

@@ -317,7 +317,7 @@ class mitarbeiter extends benutzer
 	 * gibt array mit allen Mitarbeitern zurueck
 	 * @return array mit Mitarbeitern
 	 */
-	public function getMitarbeiter($lektor=true,$fixangestellt=null,$stg_kz=null)
+	public function getMitarbeiter($lektor=true,$fixangestellt=null,$stg_kz=null, $aktiv=null)
 	{
 		$sql_query='SELECT DISTINCT campus.vw_mitarbeiter.uid, titelpre, titelpost, vorname, vornamen, wahlname, nachname, gebdatum, gebort, gebzeit, anmerkung, aktiv,
 					homepage, campus.vw_mitarbeiter.updateamum, campus.vw_mitarbeiter.updatevon, personalnummer, kurzbz, lektor, fixangestellt, standort_id, telefonklappe FROM campus.vw_mitarbeiter
@@ -346,6 +346,14 @@ class mitarbeiter extends benutzer
 			$sql_query.=" AND oe_kurzbz=".$this->db_add_param($stg->oe_kurzbz);
 		}
 
+		if(!is_null($aktiv))
+		{
+			$sql_query.=' AND';
+			if (!$aktiv)
+				$sql_query.=' NOT';
+			$sql_query.=' aktiv';
+		}
+
 		$sql_query.=' ORDER BY nachname, vornamen, kurzbz;';
 
 		if(!$this->db_query($sql_query))

include/projekt.class.php

@@ -382,7 +382,7 @@ class projekt extends basis_db
 					JOIN fue.tbl_projekt_ressource USING(ressource_id)
 					JOIN fue.tbl_projekt USING(projekt_kurzbz)
 				WHERE (beginn<=now() or beginn is null)
-				AND (ende + interval '1 month 1 day' >=now() OR ende is null)
+				AND (ende + interval '2 month 1 day' >=now() OR ende is null)
 				AND
 				(
 					mitarbeiter_uid=" . $this->db_add_param($mitarbeiter_uid) . " OR
@@ -413,6 +413,8 @@ class projekt extends basis_db
 					AND mitarbeiter_uid=" . $this->db_add_param($mitarbeiter_uid);
 		}
 
+		$qry .= ' ORDER BY titel';
+
 		if ($result = $this->db_query($qry))
 		{
 			while ($row = $this->db_fetch_object($result))

include/projektphase.class.php

@@ -190,7 +190,7 @@ class projektphase extends basis_db
 		if(!is_null($foreignkey))
 			$qry .= " and projektphase_fk is NULL";
 
-		$qry .= " ORDER BY start, projektphase_fk DESC;";
+		$qry .= " ORDER BY tbl_projektphase.start, tbl_projektphase.bezeichnung, projektphase_fk DESC;";
 
 		if($this->db_query($qry))
 		{
@@ -794,7 +794,8 @@ class projektphase extends basis_db
 			)
 		)
 		AND mitarbeiter_uid = ".$this->db_add_param($mitarbeiter_uid)."
-		AND tbl_projekt.projekt_kurzbz = ".$this->db_add_param($projekt_kurzbz);
+		AND tbl_projekt.projekt_kurzbz = ".$this->db_add_param($projekt_kurzbz). "
+		ORDER BY tbl_projektphase.start, tbl_projektphase.bezeichnung";
 
 		if($result = $this->db_query($qry))
 		{

include/tw/vilesci_menu_main.inc.php

@@ -120,6 +120,7 @@ $menu=array
 			'name'=>'Mitarbeiter','permissions'=>array('admin','mitarbeiter','support'),
 			'Übersicht'=>array('name'=>'Übersicht', 'link'=>'personen/lektor_uebersicht.php', 'target'=>'main'),
 			'Zeitsperren'=>array('name'=>'Zeitsperren/Urlaub', 'link'=>'personen/urlaubsverwaltung.php', 'target'=>'main','permissions'=>array('mitarbeiter/zeitsperre:begrenzt')),
+			'Projektexport'=>array('name'=>'Projektexport', 'link'=>'personen/projektexport.php', 'target'=>'main','permissions'=>array('mitarbeiter/zeitsperre')),
 		),
 		'Betriebsmittel'=>array('name'=>'Betriebsmittel', 'link'=>'stammdaten/betriebsmittel_frameset.php', 'target'=>'main','permissions'=>array('basis/betriebsmittel')),
 		'AnwesenheitslistenBarcode'=>array('name'=>'Anwesenheitslisten mit Barcodes', 'link'=>'personen/anwesenheitslisten_barcode.php', 'target'=>'main','permissions'=>array('basis/person')),

locale/de-AT/services.php

@@ -5,6 +5,7 @@ $this->phrasen['services/details']='Details';
 $this->phrasen['services/filtern']='Filtern';
 $this->phrasen['services/leistung']='Leistung';
 $this->phrasen['services/design']='Verantwortlich';
+$this->phrasen['services/kritikalitaet']='Kritikalität';
 $this->phrasen['services/betrieb']='Betrieb';
 $this->phrasen['services/operativ']='Operativ';
 ?>

locale/en-US/services.php

@@ -5,6 +5,7 @@ $this->phrasen['services/details']='Details';
 $this->phrasen['services/filtern']='Filter';
 $this->phrasen['services/leistung']='Service';
 $this->phrasen['services/design']='Design';
+$this->phrasen['services/kritikalitaet']='Criticality';
 $this->phrasen['services/betrieb']='Running';
 $this->phrasen['services/operativ']='Operating';
-?>
+?>

public/css/Tabulator5.css

@@ -40,7 +40,7 @@
 }
 
 .tabulator-cell .btn {
-	padding: 0 .5rem;
+	padding: 0 .7rem;
-	max-height: 22px;
+	min-height: 25px;
-	min-width: 30px;
+	min-width: 25px;
 }

public/js/api/fhcapifactory.js

@@ -0,0 +1,30 @@
+/**
+ * Copyright (C) 2024 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/>.
+ */
+
+import search from "./search.js";
+import phrasen from "./phrasen.js";
+import navigation from "./navigation.js";
+import filter from "./filter.js";
+import studstatus from "./studstatus.js";
+
+export default {
+    search,
+    phrasen,
+    navigation,
+    filter,
+    studstatus
+};

public/js/api/filter.js

@@ -0,0 +1,89 @@
+/**
+ * Copyright (C) 2024 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/>.
+ */
+
+export default {
+	saveCustomFilter(wsParams) {
+		return this.$fhcApi.post(
+			'/api/frontend/v1/filter/saveCustomFilter',
+			{
+				filterUniqueId: wsParams.filterUniqueId,
+				filterType: wsParams.filterType,
+				customFilterName: wsParams.customFilterName
+			}
+		);
+	},
+	removeCustomFilter(wsParams) {
+		return this.$fhcApi.post(
+			'/api/frontend/v1/filter/removeCustomFilter',
+			{
+				filterUniqueId: wsParams.filterUniqueId,
+				filterType: wsParams.filterType,
+				filterId: wsParams.filterId
+			}
+		);
+	},
+	applyFilterFields(wsParams) {
+		return this.$fhcApi.post(
+			'/api/frontend/v1/filter/applyFilterFields',
+			{
+				filterUniqueId: wsParams.filterUniqueId,
+				filterType: wsParams.filterType,
+				filterFields: wsParams.filterFields
+			}
+		);
+	},
+	addFilterField(wsParams) {
+		return this.$fhcApi.post(
+			'/api/frontend/v1/filter/addFilterField',
+			{
+				filterUniqueId: wsParams.filterUniqueId,
+				filterType: wsParams.filterType,
+				filterField: wsParams.filterField
+			}
+		);
+	},
+	removeFilterField(wsParams) {
+		return this.$fhcApi.post(
+			'/api/frontend/v1/filter/removeFilterField',
+			{
+				filterUniqueId: wsParams.filterUniqueId,
+				filterType: wsParams.filterType,
+				filterField: wsParams.filterField
+			}
+		);
+	},
+	getFilterById(wsParams) {
+		return this.$fhcApi.get(
+			'/api/frontend/v1/filter/getFilter',
+			{
+				filterUniqueId: wsParams.filterUniqueId,
+				filterType: wsParams.filterType,
+				filterId: wsParams.filterId
+			}
+		);
+	},
+	getFilter(wsParams) {
+		return this.$fhcApi.get(
+			'/api/frontend/v1/filter/getFilter',
+			{
+				filterUniqueId: wsParams.filterUniqueId,
+				filterType: wsParams.filterType
+			}
+		);
+	}
+};
+

public/js/api/navigation.js

@@ -0,0 +1,32 @@
+/**
+ * Copyright (C) 2024 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/>.
+ */
+
+export default {
+	getHeader(navigation_page) {
+		return this.$fhcApi.get(
+			'/api/frontend/v1/navigation/header',
+			{ navigation_page }
+		);
+	},
+	getMenu: function(navigation_page) {
+		return this.$fhcApi.get(
+			'/api/frontend/v1/navigation/menu',
+			{ navigation_page }
+		);
+	}
+};
+

public/js/api/phrasen.js

@@ -0,0 +1,22 @@
+/**
+ * Copyright (C) 2024 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/>.
+ */
+
+export default {
+	loadCategory(category) {
+		return this.$fhcApi.get('/api/frontend/v1/phrasen/loadModule/' + category);
+	}
+};

public/js/api/search.js

@@ -0,0 +1,27 @@
+/**
+ * Copyright (C) 2024 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/>.
+ */
+
+export default {
+	search(searchsettings) {
+		const url = '/api/frontend/v1/searchbar/search';
+		return this.$fhcApi.post(url, searchsettings);
+	},
+	searchdummy(searchsettings) {
+		const url = 'public/js/apps/api/dummyapi.php/Search';
+		return this.$fhcApi.post(url, searchsettings);
+	}
+};

public/js/api/studstatus.js

@@ -0,0 +1,223 @@
+/**
+ * Copyright (C) 2024 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/>.
+ */
+
+export default {
+	abmeldung: {
+		getDetails(antrag_id, prestudent_id) {
+			const url = '/api/frontend/v1/studstatus/abmeldung/'
+				+ (antrag_id !== undefined ? 'getDetailsForAntrag/' + antrag_id : 'getDetailsForNewAntrag/' + prestudent_id);
+			return this.$fhcApi.get(url);
+		},
+		create(stdsem, prestudent_id, grund) {
+			return this.$fhcApi.post('/api/frontend/v1/studstatus/abmeldung/createAntrag', {
+				studiensemester: stdsem,
+				prestudent_id,
+				grund
+			}, {
+				errorHandling: 'strict'
+			});
+		},
+		cancel(antrag_id) {
+			if (!Array.isArray(antrag_id))
+				return this.$fhcApi.post(
+					'/api/frontend/v1/studstatus/abmeldung/cancelAntrag',
+					{ antrag_id }
+				);
+			return Promise.allSettled(antrag_id.map(antrag => this.$fhcApi.post(
+				'/api/frontend/v1/studstatus/abmeldung/cancelAntrag',
+				{ antrag_id: antrag.studierendenantrag_id },
+				{ errorHeader: '#' + antrag.studierendenantrag_id }
+			)));
+		}
+	},
+	unterbrechung: {
+		getDetails(antrag_id, prestudent_id) {
+			const url = '/api/frontend/v1/studstatus/unterbrechung/'
+				+ (antrag_id !== undefined ? 'getDetailsForAntrag/' + antrag_id : 'getDetailsForNewAntrag/' + prestudent_id);
+			return this.$fhcApi.get(url);
+		},
+		create(studiensemester, prestudent_id, grund, datum_wiedereinstieg, attachment) {
+			return this.$fhcApi.post('/api/frontend/v1/studstatus/unterbrechung/createAntrag', {
+				studiensemester,
+				prestudent_id,
+				grund,
+				datum_wiedereinstieg,
+				attachment
+			}, {
+				errorHandling: 'strict'
+			});
+		},
+		cancel(antrag_id) {
+			return this.$fhcApi.post('/api/frontend/v1/studstatus/unterbrechung/cancelAntrag', {
+				antrag_id
+			}, {
+				errorHandling: 'strict'
+			});
+		}
+	},
+	wiederholung: {
+		getDetails(prestudent_id) {
+			const url = '/api/frontend/v1/studstatus/wiederholung/getDetailsForNewAntrag/' + prestudent_id;
+			return this.$fhcApi.get(url)
+		},
+		getLvs(antrag_id) {
+			const url = '/api/frontend/v1/studstatus/wiederholung/getLvs/' + antrag_id;
+			return this.$fhcApi.get(url)
+		},
+		create(prestudent_id, studiensemester) {
+			return this.$fhcApi.post('/api/frontend/v1/studstatus/wiederholung/createAntrag', {
+				prestudent_id,
+				studiensemester
+			}, {
+				errorHandling: 'strict'
+			});
+		},
+		cancel(prestudent_id, studiensemester) {
+			return this.$fhcApi.post('/api/frontend/v1/studstatus/wiederholung/cancelAntrag', {
+				prestudent_id,
+				studiensemester
+			}, {
+				errorHandling: 'strict'
+			});
+		},
+		saveLvs(forbiddenLvs, mandatoryLvs) {
+			return this.$fhcApi.post('/api/frontend/v1/studstatus/wiederholung/saveLvs', {
+				forbiddenLvs,
+				mandatoryLvs
+			});
+		}
+	},
+	leitung: {
+		getStgs() {
+			return this.$fhcApi.get('/api/frontend/v1/studstatus/leitung/getActiveStgs');
+		},
+		getAntraege(url, config, params) {
+			return this.$fhcApi
+				.get('/api/frontend/v1/studstatus/leitung/getAntraege/' + url)
+				.then(res => res.data); // Return data for tabulator
+		},
+		getHistory(antrag_id) {
+			return this.$fhcApi.get('/api/frontend/v1/studstatus/leitung/getHistory/' + antrag_id)
+		},
+		getPrestudents(query, signal) {
+			return this.$fhcApi.post(
+				'/api/frontend/v1/studstatus/leitung/getPrestudents',
+				{ query },
+				{
+                                    signal: signal,
+                                    timeout: 30000
+                                }
+			);
+		},
+		approve(antrag) {
+			if (!Array.isArray(antrag))
+				return this.$fhcApi.post(
+					'/api/frontend/v1/studstatus/leitung/approveAntrag',
+					antrag
+				);
+			return Promise.allSettled(antrag.map(a => this.$fhcApi.post(
+				'/api/frontend/v1/studstatus/leitung/approveAntrag',
+				a,
+				{ errorHeader: '#' + a.studierendenantrag_id }
+			)));
+		},
+		reject(antrag) {
+			if (!Array.isArray(antrag))
+				return this.$fhcApi.post(
+					'/api/frontend/v1/studstatus/leitung/rejectAntrag',
+					antrag
+				);
+			return Promise.allSettled(antrag.map(a => this.$fhcApi.post(
+				'/api/frontend/v1/studstatus/leitung/rejectAntrag',
+				a,
+				{ errorHeader: '#' + a.studierendenantrag_id }
+			)));
+		},
+		reopen(antrag) {
+			if (!Array.isArray(antrag))
+				return this.$fhcApi.post(
+					'/api/frontend/v1/studstatus/leitung/reopenAntrag',
+					antrag
+				);
+			return Promise.allSettled(antrag.map(a => this.$fhcApi.post(
+				'/api/frontend/v1/studstatus/leitung/reopenAntrag',
+				a,
+				{ errorHeader: '#' + a.studierendenantrag_id }
+			)));
+		},
+		pause(antrag) {
+			if (!Array.isArray(antrag))
+				return this.$fhcApi.post(
+					'/api/frontend/v1/studstatus/leitung/pauseAntrag',
+					antrag
+				);
+			return Promise.allSettled(antrag.map(a => this.$fhcApi.post(
+				'/api/frontend/v1/studstatus/leitung/pauseAntrag',
+				a,
+				{ errorHeader: '#' + a.studierendenantrag_id }
+			)));
+		},
+		unpause(antrag) {
+			if (!Array.isArray(antrag))
+				return this.$fhcApi.post(
+					'/api/frontend/v1/studstatus/leitung/unpauseAntrag',
+					antrag
+				);
+			return Promise.allSettled(antrag.map(a => this.$fhcApi.post(
+				'/api/frontend/v1/studstatus/leitung/unpauseAntrag',
+				a,
+				{ errorHeader: '#' + a.studierendenantrag_id }
+			)));
+		},
+		object(antrag) {
+			if (!Array.isArray(antrag))
+				return this.$fhcApi.post(
+					'/api/frontend/v1/studstatus/leitung/objectAntrag',
+					antrag
+				);
+			return Promise.allSettled(antrag.map(a => this.$fhcApi.post(
+				'/api/frontend/v1/studstatus/leitung/objectAntrag',
+				a,
+				{ errorHeader: '#' + a.studierendenantrag_id }
+			)));
+		},
+		approveObjection(antrag) {
+			if (!Array.isArray(antrag))
+				return this.$fhcApi.post(
+					'/api/frontend/v1/studstatus/leitung/approveObjection',
+					antrag
+				);
+			return Promise.allSettled(antrag.map(a => this.$fhcApi.post(
+				'/api/frontend/v1/studstatus/leitung/approveObjection',
+				a,
+				{ errorHeader: '#' + a.studierendenantrag_id }
+			)));
+		},
+		denyObjection(antrag) {
+			if (!Array.isArray(antrag))
+				return this.$fhcApi.post(
+					'/api/frontend/v1/studstatus/leitung/denyObjection',
+					antrag
+				);
+			return Promise.allSettled(antrag.map(a => this.$fhcApi.post(
+				'/api/frontend/v1/studstatus/leitung/denyObjection',
+				a,
+				{ errorHeader: '#' + a.studierendenantrag_id }
+			)));
+		}
+	}
+};

public/js/apps/TestSearch.js

@@ -1,195 +1,195 @@
-import {CoreFilterCmpt} from '../components/Filter.js';
+import {CoreFilterCmpt} from '../components/filter/Filter.js';
-import {CoreNavigationCmpt} from '../components/Navigation.js';
+import {CoreNavigationCmpt} from '../components/navigation/Navigation.js';
-import verticalsplit from "../components/verticalsplit/verticalsplit.js";
+import CoreVerticalsplit from "../components/verticalsplit/verticalsplit.js";
-import searchbar from "../components/searchbar/searchbar.js";
+import CoreSearchbar from "../components/searchbar/searchbar.js";
-import fhcapifactory from "./api/fhcapifactory.js";
+import FhcApi from "../plugin/FhcApi.js";
 
-Vue.$fhcapi = fhcapifactory;
+const app = Vue.createApp({
-
+	components: {
-Vue.createApp({
+		CoreNavigationCmpt,
-  "data": function() {
+		CoreFilterCmpt,
-    return {
+		CoreVerticalsplit,
-      "title": "Test Search",
+		CoreSearchbar
-      "appSideMenuEntries": {},
+	},
-      "searchbaroptions": {
+	data() {
-          "types": [
+		return {
-            "person",
+			title: "Test Search",
-            "raum",
+			appSideMenuEntries: {},
-            "mitarbeiter",
+			searchbaroptions: {
-            "student",
+				types: [
-            "prestudent",
+					"person",
-            "document",
+					"raum",
-            "cms",
+					"mitarbeiter",
-            "organisationunit"
+					"student",
-          ],
+					"prestudent",
-          "actions": {
+					"document",
-              "person": {
+					"cms",
-                  "defaultaction": {
+					"organisationunit"
-                    "type": "link",
+					],
-                    "action": function(data) { 
+				actions: {
-                      //alert('person defaultaction ' + JSON.stringify(data)); 
+					person: {
-                      //window.location.href = data.profil;
+						defaultaction: {
-                      return data.profil;
+							type: "link",
-                    }
+							action(data) { 
-                  },
+											//alert('person defaultaction ' + JSON.stringify(data)); 
-                  "childactions": [
+											//window.location.href = data.profil;
-                      {
+								return data.profil;
-                          "label": "testchildaction1",
+							}
-                          "icon": "fas fa-check-circle",
+						},
-                          "type": "function",
+						childactions: [
-                          "action": function(data) { 
+						{
-                              alert('person testchildaction 01 ' + JSON.stringify(data)); 
+							label: "testchildaction1",
-                          }
+							icon: "fas fa-check-circle",
-                      },
+							type: "function",
-                      {
+							action(data) { 
-                          "label": "testchildaction2",
+								alert('person testchildaction 01 ' + JSON.stringify(data)); 
-                          "icon": "fas fa-file-csv",
+							}
-                          "type": "function",
+						},
-                          "action": function(data) { 
+						{
-                              alert('person testchildaction 02 ' + JSON.stringify(data)); 
+							label: "testchildaction2",
-                          }
+							icon: "fas fa-file-csv",
-                      }
+							type: "function",
-                  ]
+							action(data) { 
-              },
+								alert('person testchildaction 02 ' + JSON.stringify(data)); 
-              "raum": {
+							}
-                  "defaultaction": {
+						}
-                    "type": "function",
+						]
-                    "action": function(data) { 
+					},
-                      alert('raum defaultaction ' + JSON.stringify(data)); 
+					raum: {
-                    }
+						defaultaction: {
-                  },
+							type: "function",
-                  "childactions": [                      
+							action(data) { 
-                     {
+								alert('raum defaultaction ' + JSON.stringify(data)); 
-                          "label": "Rauminformation",
+							}
-                          "icon": "fas fa-info-circle",
+						},
-                          "type": "link",
+						childactions: [                      
-                          "action": function(data) { 
+						{
-                              return data.infolink;
+							label: "Rauminformation",
-                          }
+							icon: "fas fa-info-circle",
-                      },
+							type: "link",
-                      {
+							action(data) { 
-                          "label": "Raumreservierung",
+								return data.infolink;
-                          "icon": "fas fa-bookmark",
+							}
-                          "type": "link",
+						},
-                          "action": function(data) { 
+						{
-                              return data.booklink;
+							label: "Raumreservierung",
-                          }
+							icon: "fas fa-bookmark",
-                      }
+							type: "link",
-                  ]
+							action(data) { 
-              },
+								return data.booklink;
-              "employee": {
+							}
-                  "defaultaction": {
+						}
-                    "type": "function",
+						]
-                    "action": function(data) { 
+					},
-                      alert('employee defaultaction ' + JSON.stringify(data)); 
+					employee: {
-                    }
+						defaultaction: {
-                  },
+							type: "function",
-                  "childactions": [
+							action(data) { 
-                      {
+								alert('employee defaultaction ' + JSON.stringify(data)); 
-                          "label": "testchildaction1",
+							}
-                          "icon": "fas fa-address-book",
+						},
-                          "type": "function",
+						childactions: [
-                          "action": function(data) { 
+						{
-                              alert('employee testchildaction 01 ' + JSON.stringify(data)); 
+							label: "testchildaction1",
-                          }
+							icon: "fas fa-address-book",
-                      },
+							type: "function",
-                      {
+							action(data) { 
-                          "label": "testchildaction2",
+								alert('employee testchildaction 01 ' + JSON.stringify(data)); 
-                          "icon": "fas fa-user-slash",
+							}
-                          "type": "function",
+						},
-                          "action": function(data) { 
+						{
-                              alert('employee testchildaction 02 ' + JSON.stringify(data)); 
+							label: "testchildaction2",
-                          }
+							icon: "fas fa-user-slash",
-                      },
+							type: "function",
-                      {
+							action(data) { 
-                          "label": "testchildaction3",
+								alert('employee testchildaction 02 ' + JSON.stringify(data)); 
-                          "icon": "fas fa-bell",
+							}
-                          "type": "function",
+						},
-                          "action": function(data) { 
+						{
-                              alert('employee testchildaction 03 ' + JSON.stringify(data)); 
+							label: "testchildaction3",
-                          }
+							icon: "fas fa-bell",
-                      },
+							type: "function",
-                      {
+							action(data) { 
-                          "label": "testchildaction4",
+								alert('employee testchildaction 03 ' + JSON.stringify(data)); 
-                          "icon": "fas fa-calculator",
+							}
-                          "type": "function",
+						},
-                          "action": function(data) { 
+						{
-                              alert('employee testchildaction 04 ' + JSON.stringify(data)); 
+							label: "testchildaction4",
-                          }
+							icon: "fas fa-calculator",
-                      }
+							type: "function",
-                  ]
+							action(data) { 
-              },
+								alert('employee testchildaction 04 ' + JSON.stringify(data)); 
-              "organisationunit": {
+							}
-                  "defaultaction": {
+						}
-                    "type": "function",
+						]
-                    "action": function(data) { 
+					},
-                      alert('organisationunit defaultaction ' + JSON.stringify(data)); 
+					organisationunit: {
-                    }
+						defaultaction: {
-                  },
+							type: "function",
-                  "childactions": []
+							action(data) { 
-              }
+								alert('organisationunit defaultaction ' + JSON.stringify(data)); 
-          }
+							}
-      },
+						},
-      "searchbaroptions2": {
+						childactions: []
-          "types": [
+					}
-            "raum",
+				}
-            "organisationunit"
+			},
-          ],
+			searchbaroptions2: {
-          "actions": {
+				types: [
-              "raum": {
+					"raum",
-                  "defaultaction": {
+					"organisationunit"
-                    "type": "function",
+					],
-                    "action": function(data) { 
+				actions: {
-                      alert('raum defaultaction ' + JSON.stringify(data)); 
+					raum: {
-                    }
+						defaultaction: {
-                  },
+							type: "function",
-                  "childactions": [                      
+							action(data) { 
-                     {
+								alert('raum defaultaction ' + JSON.stringify(data)); 
-                          "label": "Rauminformation",
+							}
-                          "icon": "fas fa-info-circle",
+						},
-                          "type": "link",
+						childactions: [                      
-                          "action": function(data) { 
+						{
-                              return data.infolink;
+							label: "Rauminformation",
-                          }
+							icon: "fas fa-info-circle",
-                      },
+							type: "link",
-                      {
+							action(data) { 
-                          "label": "Raumreservierung",
+								return data.infolink;
-                          "icon": "fas fa-bookmark",
+							}
-                          "type": "link",
+						},
-                          "action": function(data) { 
+						{
-                              return data.booklink;
+							label: "Raumreservierung",
-                          }
+							icon: "fas fa-bookmark",
-                      }
+							type: "link",
-                  ]
+							action(data) { 
-              },              
+								return data.booklink;
-              "organisationunit": {
+							}
-                  "defaultaction": {
+						}
-                    "type": "function",
+						]
-                    "action": function(data) { 
+					},              
-                      alert('organisationunit defaultaction ' + JSON.stringify(data)); 
+					organisationunit: {
-                    }
+						defaultaction: {
-                  },
+							type: "function",
-                  "childactions": []
+							action(data) { 
-              }
+								alert('organisationunit defaultaction ' + JSON.stringify(data)); 
-          }
+							}
-      }
+						},
-    };
+						childactions: []
-  },
+					}
-  "components": {
+				}
-    "CoreNavigationCmpt": CoreNavigationCmpt,
+			}
-    "CoreFilterCmpt": CoreFilterCmpt,
+		};
-    "verticalsplit": verticalsplit,
+	},
-    "searchbar": searchbar
+	methods: {
-  },
+		newSideMenuEntryHandler(payload) {
-  "methods": {
+			this.appSideMenuEntries = payload;
-    "newSideMenuEntryHandler": function(payload) {
+		},
-        this.appSideMenuEntries = payload;
+		searchfunction(searchsettings) {
-    },
+			return this.$fhcApi.factory.search.search(searchsettings);  
-    "searchfunction": function(searchsettings) {
+		},
-        return Vue.$fhcapi.Search.search(searchsettings);  
+		searchfunctiondummy(searchsettings) {
-    },
+			return this.$fhcApi.factory.search.searchdummy(searchsettings);  
-    "searchfunctiondummy": function(searchsettings) {
+		}
-        return Vue.$fhcapi.Search.searchdummy(searchsettings);  
+	}
-    }
+});
-  }
+app.use(FhcApi)
-}).mount('#main');
+app.mount('#main');

public/js/apps/lehre/Antrag.js

@@ -1,12 +1,10 @@
 import StudierendenantragAntrag from "../../components/Studierendenantrag/Antrag.js";
 import StudierendenantragStatus from "../../components/Studierendenantrag/Status.js";
 import StudierendenantragInfoblock from "../../components/Studierendenantrag/Infoblock.js";
-import VueDatePicker from "../../components/vueDatepicker.js.php";
 import Phrasen from '../../plugin/Phrasen.js';
 
 const app = Vue.createApp({
 	components: {
-		VueDatePicker,
 		StudierendenantragAntrag,
 		StudierendenantragStatus,
 		StudierendenantragInfoblock

public/js/components/Fetch.js

@@ -99,8 +99,10 @@ export const CoreFetchCmpt = {
 		 *
 		 */
 		errorHandler: function(error) {
-			if (error.response.data.retval)
+			if (error.response?.data?.retval)
 				this.setError(error.response.data.retval);
+			else if (error.data?.message)
+				this.setError(error.data.message);
 			else
 				this.setError(error.message);
 		},

public/js/components/Form/Form.js

@@ -46,7 +46,8 @@ export default {
 			const factory = Object.create(Object.getPrototypeOf(this.$fhcApi.factory), Object.getOwnPropertyDescriptors(this.$fhcApi.factory));
 			factory.$fhcApi = {
 				get: this.get,
-				post: this.post
+				post: this.post,
+				_defaultErrorHandlers: this.$fhcApi._defaultErrorHandlers
 			};
 			return factory;
 		}

public/js/components/Form/Input.js

@@ -160,12 +160,12 @@ export default {
 		},
 		modelValueCmp: {
 			get() {
-				if (this.$attrs.modelValue === undefined)
+				if (!this.$attrs.hasOwnProperty('modelValue'))
 					return this.modelValueDummy;
 				return this.$attrs.modelValue;
 			},
 			set(v) {
-				if (this.$attrs.modelValue === undefined)
+				if (!this.$attrs.hasOwnProperty('modelValue'))
 					this.modelValueDummy = v;
 				this.$emit('update:modelValue', v);
 			}
@@ -236,12 +236,13 @@ export default {
 	},
 	template: `
 	<component :is="!hasContainer ? 'FhcFragment' : 'div'" class="position-relative" :class="autoContainerClass">
-		<label v-if="$attrs.label && lcType != 'radio' && lcType != 'checkbox'" :for="idCmp">{{$attrs.label}}</label>
+		<label v-if="$attrs.label && lcType != 'radio' && lcType != 'checkbox'" :class="!noAutoClass && 'form-label'" :for="idCmp">{{$attrs.label}}</label>
 		<input v-if="tag == 'input'" :type="lcType" ref="input" v-model="modelValueCmp" v-bind="$attrs" :id="idCmp" :name="name" :class="validationClass" :modelValue="undefined" @input="clearValidationForThisName(); $emit('input', $event)">
 		<textarea v-else-if="tag == 'textarea'" ref="input" v-model="modelValueCmp" v-bind="$attrs" :id="idCmp" :name="name" :class="validationClass" :modelValue="undefined" @input="clearValidationForThisName(); $emit('input', $event)"></textarea>
 		<select v-else-if="tag == 'select'" ref="input" v-model="modelValueCmp" v-bind="$attrs" :id="idCmp" :name="name" :class="validationClass" :modelValue="undefined" @input="clearValidationForThisName(); $emit('input', $event)">
 			<slot></slot>
 		</select>
+
 		<component
 			v-else-if="tag == 'VueDatePicker'"
 			ref="input"
@@ -272,6 +273,17 @@ export default {
 			@update:model-value="clearValidationForThisName"
 			>
 			<slot></slot>
+			<template #chip="data"><slot name="chip" v-bind="data"></slot></template>
+			<template #header="data"><slot name="header" v-bind="data"></slot></template>
+			<template #footer="data"><slot name="footer" v-bind="data"></slot></template>
+			<template #option="data"><slot name="option" v-bind="data"></slot></template>
+			<template #optiongroup="data"><slot name="optiongroup" v-bind="data"></slot></template>
+			<template #content="data"><slot name="content" v-bind="data"></slot></template>
+			<template #loader="data"><slot name="loader" v-bind="data"></slot></template>
+			<template #empty="data"><slot name="empty" v-bind="data"></slot></template>
+			<template #dropdownicon="data"><slot name="dropdownicon" v-bind="data"></slot></template>
+			<template #removetokenicon="data"><slot name="removetokenicon" v-bind="data"></slot></template>
+			<template #loadingicon="data"><slot name="loadingicon" v-bind="data"></slot></template>
 		</component>
 		<component
 			v-else-if="tag == 'UploadDms'"

public/js/components/Studierendenantrag/Form/Abmeldung.js

@@ -1,10 +1,16 @@
 import {CoreFetchCmpt} from '../../Fetch.js';
+import CoreForm from '../../Form/Form.js';
+import FormValidation from '../../Form/Validation.js';
+import FormInput from '../../Form/Input.js';
 
 var _uuid = 0;
 
 export default {
 	components: {
-		CoreFetchCmpt
+		CoreFetchCmpt,
+		CoreForm,
+		FormValidation,
+		FormInput
 	},
 	emits: [
 		'setInfos',
@@ -18,9 +24,8 @@ export default {
 		return {
 			data: null,
 			saving: false,
-			errors: {
+			formData: {
-				grund: [],
+				grund: ''
-				default: []
 			}
 		}
 	},
@@ -34,24 +39,14 @@ export default {
 				case 'Genehmigt': return 'success';
 				default: return 'warning';
 			}
-		},
-		loadUrl() {
-			if (this.studierendenantragId)
-				return '/components/Antrag/Abmeldung/getDetailsForAntrag/'+
-				this.studierendenantragId;
-			return '/components/Antrag/Abmeldung/getDetailsForNewAntrag/' +
-				this.prestudentId;
 		}
 	},
 	methods: {
 		load() {
-			return axios.get(
+			return this.$fhcApi.factory
-				FHC_JS_DATA_STORAGE_OBJECT.app_root +
+				.studstatus.abmeldung.getDetails(this.studierendenantragId, this.prestudentId)
-				FHC_JS_DATA_STORAGE_OBJECT.ci_router +
+				.then(result => {
-				this.loadUrl
+					this.data = result.data;
-			).then(
-				result => {
-					this.data = result.data.retval;
 					if (this.data.status) {
 						const msg = (this.data.status == 'Pause' && this.data.status_insertvon == "Studienabbruch") ? Vue.computed(() => {
 							let status = this.$p.t('studierendenantrag/status_stop');
@@ -63,8 +58,8 @@ export default {
 						});
 					}
 					return result;
-				}
+				})
-			);
+				.catch(this.$fhcAlert.handleSystemError);
 		},
 		createAntrag() {
 			bootstrap.Modal.getOrCreateInstance(this.$refs.modal).hide();
@@ -73,52 +68,39 @@ export default {
 				severity: 'warning'
 			});
 			this.saving = true;
-			for(var k in this.errors)
+
-				this.errors[k] = [];
+			this.$refs.form.clearValidation();
-			axios.post(
+			this.$refs.form.factory
-				FHC_JS_DATA_STORAGE_OBJECT.app_root +
+				.studstatus.abmeldung.create(
-				FHC_JS_DATA_STORAGE_OBJECT.ci_router +
+					this.data.studiensemester_kurzbz,
-				'/components/Antrag/Abmeldung/createAntrag/', {
+					this.data.prestudent_id,
-					studiensemester: this.data.studiensemester_kurzbz,
+					this.formData.grund
-					prestudent_id: this.data.prestudent_id,
+				)
-					grund: this.$refs.grund.value
+				.then(result => {
-				}
+					if (result.data === true)
-			).then(
+						document.location += "";
-				result => {
+
-					if (result.data.error)
+					this.data = result.data;
-					{
+					if (this.data.status)
-						for (var k in result.data.retval)
+						this.$emit("setStatus", {
-						{
+							msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.data.statustyp})),
-							if (this.errors[k] !== undefined)
+							severity: this.statusSeverity
-								this.errors[k].push(result.data.retval[k]);
-							else
-								this.errors.default.push(result.data.retval[k]);
-						}
-						this.$emit('setStatus', {
-							msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.$p.t('studierendenantrag', 'status_error')})),
-							severity: 'danger'
 						});
-					}
 					else
-					{
+						this.$emit('setStatus', {
-						if (result.data.retval === true)
+							msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.$p.t('studierendenantrag', 'status_open')})),
-							document.location += "";
+							severity:'success'
-						this.data = result.data.retval;
+						});
-						if (this.data.status) {
-							this.$emit("setStatus", {
-								msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.data.statustyp})),
-								severity: this.statusSeverity
-							});
-						}
-						else
-							this.$emit('setStatus', {
-								msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.$p.t('studierendenantrag', 'status_open')})),
-								severity:'success'
-							});
-					}
 					this.saving = false;
-				}
+				})
-			);
+				.catch(error => {
+					this.$emit('setStatus', {
+						msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.$p.t('studierendenantrag', 'status_error')})),
+						severity: 'danger'
+					});
+					this.saving = false;
+					this.$fhcAlert.handleSystemError(error);
+				});
 		},
 		cancelAntrag() {
 			this.$emit('setStatus', {
@@ -126,51 +108,37 @@ export default {
 				severity: 'warning'
 			});
 			this.saving = true;
-			for(var k in this.errors)
+
-				this.errors[k] = [];
+			this.$refs.form.clearValidation();
-			axios.post(
+			this.$refs.form.factory
-				FHC_JS_DATA_STORAGE_OBJECT.app_root +
+				.studstatus.abmeldung.cancel(
-				FHC_JS_DATA_STORAGE_OBJECT.ci_router +
+					this.data.studierendenantrag_id
-				'/components/Antrag/Abmeldung/cancelAntrag/', {
+				)
-					antrag_id: this.data.studierendenantrag_id
+				.then(result => {
-				}
+					if (Number.isInteger(result.data))
-			).then(
+						document.location = document.location.replace(/abmeldung\/([0-9]*)\/[0-9]*[\/]?$/, 'abmeldung/$1') +  "/" + result.data;
-				result => {
+					
-					if (result.data.error)
+					this.data = result.data;
-					{
+					if (this.data.status)
-						for (var k in result.data.retval)
+						this.$emit("setStatus", {
-						{
+							msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.data.statustyp})),
-							if (this.errors[k] !== undefined)
+							severity: this.statusSeverity
-								this.errors[k].push(result.data.retval[k]);
-							else
-								this.errors.default.push(result.data.retval[k]);
-						}
-						this.$emit('setStatus', {
-							msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.$p.t('studierendenantrag', 'status_error')})),
-							severity:'danger'
 						});
-					}
 					else
-					{
+						this.$emit('setStatus', {
-						if (Number.isInteger(result.data.retval)) {
+							msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.$p.t('studierendenantrag', 'status_cancelled')})),
-							document.location = document.location.replace(/abmeldung\/([0-9]*)\/[0-9]*[\/]?$/, 'abmeldung/$1') +  "/" + result.data.retval;
+							severity: 'danger'
-						}
+						});
-						this.data = result.data.retval;
-						if (this.data.status) {
-							this.$emit("setStatus", {
-								msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.data.statustyp})),
-								severity: this.statusSeverity
-							});
-						}
-						else
-							this.$emit('setStatus', {
-								msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.$p.t('studierendenantrag', 'status_cancelled')})),
-								severity: 'danger'
-							});
-					}
 					this.saving = false;
-				}
+				})
-			);
+				.catch(error => {
+					this.$emit('setStatus', {
+						msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.$p.t('studierendenantrag', 'status_error')})),
+						severity: 'danger'
+					});
+					this.saving = false;
+					this.$fhcAlert.handleSystemError(error);
+				});
 		}
 	},
 	created() {
@@ -179,10 +147,9 @@ export default {
 	template: `
 	<div class="studierendenantrag-form-abmeldung">
 		<core-fetch-cmpt :api-function="load">
-			<div class="row">
+			<core-form ref="form" class="row">
 				<div class="col-12">
-					<div v-for="error in errors.default" class="alert alert-danger" role="alert" v-html="error">
+					<form-validation></form-validation>
-					</div>
 					<table class="table">
 						<tr>
 							<th>{{$p.t('lehre', 'studiengang')}}</th>
@@ -219,19 +186,16 @@ export default {
 					<pre>{{data.grund}}</pre>
 				</div>
 				<div v-else class="col-sm-6 mb-3">
-					<label :for="'studierendenantrag-form-abmeldung-' + uuid + '-grund'" class="form-label">Grund:</label>
+					<form-input
-					<textarea
+						type="textarea"
-						class="form-control"
+						label="Grund:"
-						:class="{'is-invalid': errors.grund.length}"
+						v-model="formData.grund"
-						:id="'studierendenantrag-form-abmeldung-' + uuid + '-grund'"
+						name="grund"
 						rows="5"
 						:disabled="saving"
-						ref="grund"
 						required
-						></textarea>
+						>
-					<div v-if="errors.grund.length" class="invalid-feedback">
+					</form-input>
-						{{errors.grund.join(".")}}
-					</div>
 				</div>
 				<div class="col-12 text-end">
 					<button
@@ -286,13 +250,13 @@ export default {
 						</div>
 					</div>
 				</div>
-			</div>
+			</core-form>
+			
 			<template v-slot:error="{errorMessage}">
 				<div class="alert alert-danger m-0" role="alert">
 					{{ errorMessage }}
 				</div>
 			</template>
 		</core-fetch-cmpt>
-	</div>
+	</div>`
-	`
 }

public/js/components/Studierendenantrag/Form/AbmeldungStgl.js

@@ -1,10 +1,16 @@
 import {CoreFetchCmpt} from '../../Fetch.js';
+import CoreForm from '../../Form/Form.js';
+import FormValidation from '../../Form/Validation.js';
+import FormInput from '../../Form/Input.js';
 
 var _uuid = 0;
 
 export default {
 	components: {
-		CoreFetchCmpt
+		CoreFetchCmpt,
+		CoreForm,
+		FormValidation,
+		FormInput
 	},
 	emits: [
 		'setInfos',
@@ -18,9 +24,8 @@ export default {
 		return {
 			data: null,
 			saving: false,
-			errors: {
+			formData: {
-				grund: [],
+				grund: ''
-				default: []
 			}
 		}
 	},
@@ -35,24 +40,14 @@ export default {
 				case 'Abgemeldet': return 'success';
 				default: return 'warning';
 			}
-		},
-		loadUrl() {
-			if (this.studierendenantragId)
-				return '/components/Antrag/Abmeldung/getDetailsForAntrag/'+
-					this.studierendenantragId;
-			return '/components/Antrag/Abmeldung/getDetailsForNewAntrag/' +
-				this.prestudentId;
 		}
 	},
 	methods: {
 		load() {
-			return axios.get(
+			return this.$fhcApi.factory
-				FHC_JS_DATA_STORAGE_OBJECT.app_root +
+				.studstatus.abmeldung.getDetails(this.studierendenantragId, this.prestudentId)
-				FHC_JS_DATA_STORAGE_OBJECT.ci_router +
+				.then(result => {
-				this.loadUrl
+					this.data = result.data;
-			).then(
-				result => {
-					this.data = result.data.retval;
 					if (this.data.status) {
 						const msg = (this.data.status == 'Pause' && this.data.status_insertvon == "Studienabbruch") ? Vue.computed(() => {
 							let status = this.$p.t('studierendenantrag/status_stop');
@@ -64,8 +59,7 @@ export default {
 						});
 					}
 					return result;
-				}
+				});
-			);
 		},
 		createAntrag() {
 			bootstrap.Modal.getOrCreateInstance(this.$refs.modal).hide();
@@ -74,63 +68,44 @@ export default {
 				severity: 'warning'
 			});
 			this.saving = true;
-			for(var k in this.errors)
-				this.errors[k] = [];
-			axios.post(
-				FHC_JS_DATA_STORAGE_OBJECT.app_root +
-				FHC_JS_DATA_STORAGE_OBJECT.ci_router +
-				'/components/Antrag/Abmeldung/createAntrag/', {
-					studiensemester: this.data.studiensemester_kurzbz,
-					prestudent_id: this.data.prestudent_id,
-					grund: this.$refs.grund.value
-				}
-			).then(
-				result => {
-					if (result.data.error)
-					{
-						for (var k in result.data.retval)
-						{
-							if (this.errors[k] !== undefined)
-								this.errors[k].push(result.data.retval[k]);
-							else
-								this.errors.default.push(result.data.retval[k]);
-						}
-						this.$emit('setStatus', {
-							msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.$p.t('studierendenantrag', 'status_error')})),
-							severity: 'danger'
-						});
-					}
-					else
-					{
-						if (result.data.retval === true)
-							document.location += "";
-						this.data = result.data.retval;
-						if (this.data.status) {
-							this.$emit("setStatus", {
-								msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.data.statustyp})),
-								severity: this.statusSeverity
-							});
-						}
-						else
-							this.$emit('setStatus', {
-								msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.$p.t('studierendenantrag', 'status_open')})),
-								severity:'success'
-							});
-					}
-					this.saving = false;
-				}
-			);
-		},
-		appendDropDownText(event){
-			let templateText = this.$refs.grund;
 
-			if(event.target.value)
+			this.$refs.form.clearValidation();
-			{
+			this.$refs.form.factory
-				let templateT= this.$p.t('studierendenantrag', event.target.value);
+				.studstatus.abmeldung.create(
-				templateText.value = templateT;
+					this.data.studiensemester_kurzbz,
-			}
+					this.data.prestudent_id,
-			else
+					this.formData.grund
-				templateText.value = '';
+				)
+				.then(result => {
+					if (result.data === true)
+						document.location += "";
+					
+					this.data = result.data;
+					if (this.data.status)
+						this.$emit("setStatus", {
+							msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.data.statustyp})),
+							severity: this.statusSeverity
+						});
+					else
+						this.$emit('setStatus', {
+							msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.$p.t('studierendenantrag', 'status_open')})),
+							severity:'success'
+						});
+					this.saving = false;
+				})
+				.catch(error => {
+					this.$emit('setStatus', {
+						msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.$p.t('studierendenantrag', 'status_error')})),
+						severity: 'danger'
+					});
+					this.saving = false;
+					this.$fhcAlert.handleSystemError(error);
+				});
+		},
+		appendDropDownText(event) {
+			this.formData.grund = event.target.value
+				? this.$p.t('studierendenantrag', event.target.value)
+				: '';
 		},
 	},
 	created() {
@@ -139,8 +114,9 @@ export default {
 	template: `
 	<div class="studierendenantrag-form-abmeldung">
 		<core-fetch-cmpt :api-function="load">
-			<div class="row">
+			<core-form ref="form" class="row">
 				<div class="col-12">
+					<form-validation></form-validation>
 					<table class="table">
 						<tr>
 							<th>{{$p.t('lehre', 'studiengang')}}</th>
@@ -181,8 +157,7 @@ export default {
 				<div v-else class="col-sm-6 mb-3">
 					<label :for="'studierendenantrag-form-abmeldung-' + uuid + '-grund'" class="form-label">Grund:</label>
 					<div class="mb-2">
-						<select name="grundAv" @change="appendDropDownText
+						<select name="grundAv" class="form-select" @change="appendDropDownText">
-							($event)">
 							<option value="" > --- bitte auswählen, sofern zutreffend ---- </option>
 							<option value="textLong_NichtantrittStudium">{{$p.t('studierendenantrag', 'dropdown_NichtantrittStudium')}}
 							</option>
@@ -199,19 +174,17 @@ export default {
 							<option value="textLong_MissingZgv">{{$p.t('studierendenantrag', 'dropdown_MissingZgv')}}
 							</option>						
 						</select>	
-					</div>			
+					</div>
-					<textarea
+					<form-input
-						class="form-control"
+						type="textarea"
-						:class="{'is-invalid': errors.grund.length}"
+						v-model="formData.grund"
+						name="grund"
 						:id="'studierendenantrag-form-abmeldung-' + uuid + '-grund'"
 						rows="5"
 						:disabled="saving"
-						ref="grund"
 						required
-						></textarea>
+						>
-					<div v-if="errors.grund.length" class="invalid-feedback">
+					</form-input>
-						{{errors.grund.join(".")}}
-					</div>
 				</div>
 				
 				<div class="col-12 text-end">
@@ -257,7 +230,7 @@ export default {
 						</div>
 					</div>
 				</div>
-			</div>
+			</core-form>
 			
 			<template v-slot:error="{errorMessage}">
 				<div class="alert alert-danger m-0" role="alert">
@@ -265,6 +238,5 @@ export default {
 				</div>
 			</template>
 		</core-fetch-cmpt>
-	</div>
+	</div>`
-	`
 }

public/js/components/Studierendenantrag/Form/Unterbrechung.js

@@ -1,12 +1,15 @@
 import {CoreFetchCmpt} from '../../Fetch.js';
-import VueDatepicker from '../../vueDatepicker.js.php';
+import CoreForm from '../../Form/Form.js';
+import FormValidation from '../../Form/Validation.js';
+import FormInput from '../../Form/Input.js';
 
-var _uuid = 0;
 
 export default {
 	components: {
 		CoreFetchCmpt,
-		VueDatepicker
+		CoreForm,
+		FormValidation,
+		FormInput
 	},
 	emits: [
 		'setInfos',
@@ -20,12 +23,7 @@ export default {
 		return {
 			data: null,
 			saving: false,
-			errors: {
+			attachment: [],
-				grund: [],
-				studiensemester: [],
-				datum_wiedereinstieg: [],
-				default: []
-			},
 			stsem: null,
 			currentWiedereinstieg: '',
 			siteUrl: FHC_JS_DATA_STORAGE_OBJECT.app_root +
@@ -45,13 +43,6 @@ export default {
 				default: return 'warning';
 			}
 		},
-		loadUrl() {
-			if (this.studierendenantragId)
-				return '/components/Antrag/Unterbrechung/getDetailsForAntrag/'+
-				this.studierendenantragId;
-			return '/components/Antrag/Unterbrechung/getDetailsForNewAntrag/' +
-				this.prestudentId;
-		},
 		datumWsFormatted() {
 			let datumUnformatted = '';
 
@@ -81,26 +72,24 @@ export default {
 	},
 	methods: {
 		load() {
-			return axios.get(
+			return this.$fhcApi.factory
-				FHC_JS_DATA_STORAGE_OBJECT.app_root +
+				.studstatus.unterbrechung.getDetails(this.studierendenantragId, this.prestudentId)
-				FHC_JS_DATA_STORAGE_OBJECT.ci_router +
+				.then(
-				this.loadUrl
+					result => {
-			).then(
+						this.data = result.data;
-				result => {
+						if (this.data.status) {
-					this.data = result.data.retval;
+							const msg = (this.data.status == 'Pause' && this.data.status_insertvon == "Studienabbruch") ? Vue.computed(() => {
-					if (this.data.status) {
+								let status = this.$p.t('studierendenantrag/status_stop');
-						const msg = (this.data.status == 'Pause' && this.data.status_insertvon == "Studienabbruch") ? Vue.computed(() => {
+								return this.$p.t('studierendenantrag', 'status_x', {status});
-							let status = this.$p.t('studierendenantrag/status_stop');
+							}) : Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.data.statustyp}));
-							return this.$p.t('studierendenantrag', 'status_x', {status});
+							this.$emit("setStatus", {
-						}) : Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.data.statustyp}));
+								msg,
-						this.$emit("setStatus", {
+								severity: this.statusSeverity
-							msg,
+							});
-							severity: this.statusSeverity
+						}
-						});
+						return result;
 					}
-					return result;
+				);
-				}
-			);
 		},
 		createAntrag() {
 			this.$emit('setStatus', {
@@ -108,63 +97,41 @@ export default {
 				severity: 'warning'
 			});
 			this.saving = true;
-			for(var k in this.errors)
-				this.errors[k] = [];
 
-			var formData = new FormData();
+			this.$refs.form.clearValidation();
-			var attachment = this.$refs.attachment;
+			this.$refs.form.factory
-			formData.append("attachment", attachment.files[0]);
+				.studstatus.unterbrechung.create(
-			formData.append("studiensemester", this.stsem !== null && this.data.studiensemester[this.stsem].studiensemester_kurzbz);
+					this.stsem !== null && this.data.studiensemester[this.stsem].studiensemester_kurzbz,
-			formData.append("prestudent_id", this.data.prestudent_id);
+					this.data.prestudent_id,
-			formData.append("grund", this.$refs.grund.value);
+					this.data.grund,
-			formData.append("datum_wiedereinstieg", this.stsem !== null && this.currentWiedereinstieg);
+					this.stsem !== null && this.currentWiedereinstieg,
+					this.attachment
+				)
+				.then(result => {
+					if (Number.isInteger(result.data))
+						document.location += "/" + result.data;
 
-			axios.post(
+					this.data = result.data;
-				FHC_JS_DATA_STORAGE_OBJECT.app_root +
+					if (this.data.status)
-				FHC_JS_DATA_STORAGE_OBJECT.ci_router +
+						this.$emit("setStatus", {
-				'/components/Antrag/Unterbrechung/createAntrag/',
+							msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.data.statustyp})),
-				formData,
+							severity: this.statusSeverity
-				{
-					headers: {
-						'Content-Type': 'multipart/form-data'
-					}
-				}
-			).then(
-				result => {
-					if (result.data.error)
-					{
-						for (var k in result.data.retval)
-						{
-							if (this.errors[k] !== undefined)
-								this.errors[k].push(result.data.retval[k]);
-							else
-								this.errors.default.push(result.data.retval[k]);
-						}
-						this.$emit('setStatus', {
-							msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.$p.t('studierendenantrag', 'status_error')})),
-							severity: 'danger'
 						});
-					}
 					else
-					{
+						this.$emit('setStatus', {
-						if (Number.isInteger(result.data.retval))
+							msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.$p.t('studierendenantrag', 'status_created')})),
-							document.location += "/" + result.data.retval;
+							severity: 'info'
-						this.data = result.data.retval;
+						});
-						if (this.data.status) {
-							this.$emit("setStatus", {
-								msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.data.statustyp})),
-								severity: this.statusSeverity
-							});
-						}
-						else
-							this.$emit('setStatus', {
-								msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.$p.t('studierendenantrag', 'status_created')})),
-								severity: 'info'
-							});
-					}
 					this.saving = false;
-				}
+				})
-			);
+				.catch(error => {
+					this.$emit('setStatus', {
+						msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.$p.t('studierendenantrag', 'status_error')})),
+						severity: 'danger'
+					});
+					this.saving = false;
+					this.$fhcAlert.handleSystemError(error);
+				});
 		},
 		cancelAntrag() {
 			this.$emit('setStatus', {
@@ -172,63 +139,45 @@ export default {
 				severity: 'warning'
 			});
 			this.saving = true;
-			for(var k in this.errors)
+
-				this.errors[k] = [];
+			this.$refs.form.clearValidation();
-			axios.post(
+			this.$refs.form.factory
-				FHC_JS_DATA_STORAGE_OBJECT.app_root +
+				.studstatus.unterbrechung.cancel(
-				FHC_JS_DATA_STORAGE_OBJECT.ci_router +
+					this.data.studierendenantrag_id
-				'/components/Antrag/Unterbrechung/cancelAntrag/', {
+				)
-					antrag_id: this.data.studierendenantrag_id
+				.then(result => {
-				}
+					if (Number.isInteger(result.data))
-			).then(
+						document.location = document.location.replace(/unterbrechung\/([0-9]*)\/[0-9]*[\/]?$/, 'unterbrechung/$1') +  "/" + result.data;
-				result => {
+
-					if (result.data.error)
+					this.data = result.data;
-					{
+					if (this.data.status)
-						for (var k in result.data.retval)
+						this.$emit("setStatus", {
-						{
+							msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.data.statustyp})),
-							if (this.errors[k] !== undefined)
+							severity: this.statusSeverity
-								this.errors[k].push(result.data.retval[k]);
+						});
-							else
+					else
-								this.errors.default.push(result.data.retval[k]);
-						}
 						this.$emit('setStatus', {
-							msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.$p.t('studierendenantrag', 'status_error')})),
+							msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.$p.t('studierendenantrag', 'status_cancelled')})),
 							severity: 'danger'
 						});
-					}
-					else
-					{
-						if (Number.isInteger(result.data.retval)) {
-							document.location = document.location.replace(/unterbrechung\/([0-9]*)\/[0-9]*[\/]?$/, 'unterbrechung/$1') +  "/" + result.data.retval;
-						}
-						this.data = result.data.retval;
-						if (this.data.status) {
-							this.$emit("setStatus", {
-								msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.data.statustyp})),
-								severity: this.statusSeverity
-							});
-						}
-						else
-							this.$emit('setStatus', {
-								msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.$p.t('studierendenantrag', 'status_cancelled')})),
-								severity: 'danger'
-							});
-					}
 					this.saving = false;
-				}
+				})
-			);
+				.catch(error => {
+					this.$emit('setStatus', {
+						msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.$p.t('studierendenantrag', 'status_error')})),
+						severity: 'danger'
+					});
+					this.saving = false;
+					this.$fhcAlert.handleSystemError(error);
+				});
 		}
 	},
-	created() {
-		this.uuid = _uuid++;
-	},
 	template: `
 	<div class="studierendenantrag-form-unterbrechung">
 		<core-fetch-cmpt :api-function="load">
-			<div class="row">
+			<core-form ref="form" class="row">
 				<div class="col-12">
-					<div v-for="error in errors.default" class="alert alert-danger" role="alert" v-html="error">
+					<form-validation></form-validation>
-					</div>
 					<table class="table">
 						<tr>
 							<th>{{$p.t('lehre', 'studiengang')}}</th>
@@ -260,93 +209,99 @@ export default {
 				</div>
 
 				<div class="col-sm-6 mb-3">
-					<label :for="'studierendenantrag-form-abmeldung-' + uuid + '-stsem'" class="form-label">
-						{{$p.t('lehre', 'studiensemester')}}
-					</label>
 					<div v-if="data.studierendenantrag_id">
-						{{data.studiensemester_kurzbz}}
+						<label class="form-label">
-					</div>
+							{{$p.t('lehre', 'studiensemester')}}
-					<div v-else>
+						</label>
-						<select
+						<div>
-							class="form-select"
+							{{data.studiensemester_kurzbz}}
-							:class="{'is-invalid': errors.studiensemester.length}"
-							v-model="stsem"
-							required
-							:id="'studierendenantrag-form-abmeldung-' + uuid + '-stsem'"
-							@input="currentWiedereinstieg = ''"
-							>
-							<option v-for="(stsem, index) in data.studiensemester" :key="index" :value="index" :disabled="stsem.disabled">
-								{{stsem.studiensemester_kurzbz}}
-							</option>
-						</select>
-						<div v-if="errors.studiensemester.length" class="invalid-feedback">
-							{{errors.studiensemester.join(".")}}
 						</div>
 					</div>
+					<form-input
+						v-else
+						type="select"
+						v-model="stsem"
+						name="studiensemester"
+						:label="$p.t('lehre', 'studiensemester')"
+						required
+						@input="currentWiedereinstieg = ''"
+						>
+						<option v-for="(stsem, index) in data.studiensemester" :key="index" :value="index" :disabled="stsem.disabled">
+							{{stsem.studiensemester_kurzbz}}
+						</option>
+					</form-input>
 				</div>
 				<div class="col-sm-6 mb-3">
-					<label class="form-label">
-						{{$p.t('studierendenantrag', 'antrag_datum_wiedereinstieg')}}
-					</label>
-
 					<div v-if="data.studierendenantrag_id">
-						{{datumWsFormatted}}
+						<label class="form-label">
-					</div>
+							{{$p.t('studierendenantrag', 'antrag_datum_wiedereinstieg')}}
-					<div v-else-if="stsem === null">
+						</label>
-						<select class="form-select" disabled>
+						<div>
-							<option selected>{{$p.t('ui/select_studiensemester')}}</option>
+							{{datumWsFormatted}}
-						</select>
+						</div>
-					</div>
-					<div v-else>
-						<select v-model="currentWiedereinstieg" class="form-select">
-							<option v-for="sem in data.studiensemester[stsem].wiedereinstieg" :key="sem.studiensemester_kurzbz" :value="sem.start" :disabled="sem.disabled">
-								{{sem.studiensemester_kurzbz}}
-							</option>
-						</select>
-					</div>
-
-					<div v-if="errors.datum_wiedereinstieg.length" class="invalid-feedback d-block">
-						{{errors.datum_wiedereinstieg.join(".")}}
 					</div>
+					<form-input
+						v-else-if="stsem === null"
+						type="select"
+						:label="$p.t('studierendenantrag', 'antrag_datum_wiedereinstieg')"
+						modelValue=""
+						name="datum_wiedereinstieg"
+						disabled
+						>
+						<template #default>
+							<option value="" selected disabled hidden>{{$p.t('ui/select_studiensemester')}}</option>
+						</template>
+					</form-input>
+					<form-input
+						v-else
+						type="select"
+						:label="$p.t('studierendenantrag', 'antrag_datum_wiedereinstieg')"
+						v-model="currentWiedereinstieg"
+						name="datum_wiedereinstieg"
+						>
+						<option v-for="sem in data.studiensemester[stsem].wiedereinstieg" :key="sem.studiensemester_kurzbz" :value="sem.start" :disabled="sem.disabled">
+							{{sem.studiensemester_kurzbz}}
+						</option>
+					</form-input>
 				</div>
-				<div v-if="data.studierendenantrag_id" class="mb-3">
+				<div class="col-sm-6 mb-3">
-					<h5>{{$p.t('studierendenantrag', 'antrag_grund')}}:</h5>
+					<form-input
-					<textarea class="form-control" rows="5" readonly>{{data.grund}}</textarea>
+						v-if="data.studierendenantrag_id"
-				</div>
+						type="textarea"
-				<div v-else class="col-sm-6 mb-3">
+						:label="$p.t('studierendenantrag', 'antrag_grund') + ':'"
-					<label :for="'studierendenantrag-form-abmeldung-' + uuid + '-grund'" class="form-label">Grund:</label>
+						v-model="data.grund"
-					<textarea
+						name="grund"
-						class="form-control"
-						:class="{'is-invalid': errors.grund.length}"
-						:id="'studierendenantrag-form-abmeldung-' + uuid + '-grund'"
 						rows="5"
-						:disabled="saving"
+						readonly
+						>
+					</form-input>
+					<form-input
+						v-else
 						ref="grund"
+						type="textarea"
+						:label="$p.t('studierendenantrag', 'antrag_grund') + ':'"
+						v-model="data.grund"
+						name="grund"
+						:disabled="saving"
+						rows="5"
 						required
-						></textarea>
+						>
-					<div v-if="errors.grund.length" class="invalid-feedback">
+					</form-input>
-						{{errors.grund.join(".")}}
-					</div>
 				</div>
 				<div class="col-12 mb-3">
-
 					<div v-if="data.studierendenantrag_id">
 						<a v-if="data.dms_id" target="_blank" :href="siteUrl + '/lehre/Antrag/Attachment/Show/' + data.dms_id"> {{$p.t('studierendenantrag', 'antrag_dateianhaenge')}} </a>
 						<span v-else>{{$p.t('studierendenantrag', 'no_attachments')}}</span>
 					</div>
-					<div v-else>
+					<form-input
-						<label
+						v-else
-							:for="'studierendenantrag-form-abmeldung-' + uuid + '-attachment'"
+						ref="attachment"
-							class="form-label">
+						type="uploadfile"
-							{{$p.t('studierendenantrag', 'antrag_dateianhaenge')}}
+						:label="$p.t('studierendenantrag', 'antrag_dateianhaenge')"
-						</label>
+						v-model="attachment"
-						<input
+						name="attachment"
-							class="form-control"
+						>
-							type="file"
+					</form-input>
-							ref="attachment"
-							:id="'studierendenantrag-form-abmeldung-' + uuid + '-attachment'"
-							name="attachment">
-					</div>
 				</div>
 				<div class="col-12 text-end">
 					<button
@@ -368,13 +323,12 @@ export default {
 						{{$p.t('studierendenantrag', 'btn_cancel')}}
 					</button>
 				</div>
-			</div>
+			</core-form>
 			<template v-slot:error="{errorMessage}">
 				<div class="alert alert-danger m-0" role="alert">
 					{{ errorMessage }}
 				</div>
 			</template>
 		</core-fetch-cmpt>
-	</div>
+	</div>`
-	`
 }

public/js/components/Studierendenantrag/Form/Wiederholung.js

@@ -1,12 +1,13 @@
 import {CoreFetchCmpt} from '../../Fetch.js';
-import VueDatepicker from '../../vueDatepicker.js.php';
+import CoreForm from '../../Form/Form.js';
+import FormValidation from '../../Form/Validation.js';
 
-var _uuid = 0;
 
 export default {
 	components: {
 		CoreFetchCmpt,
-		VueDatepicker
+		CoreForm,
+		FormValidation
 	},
 	emits: [
 		'setInfos',
@@ -22,12 +23,6 @@ export default {
 		return {
 			data: null,
 			saving: false,
-			errors: {
-				grund: [],
-				default: []
-			},
-			siteUrl: FHC_JS_DATA_STORAGE_OBJECT.app_root +
-				FHC_JS_DATA_STORAGE_OBJECT.ci_router,
 			infos: []
 		}
 	},
@@ -45,10 +40,6 @@ export default {
 				default: return 'warning';
 			}
 		},
-		loadUrl() {
-			return '/components/Antrag/Wiederholung/getDetailsForNewAntrag/' +
-				this.prestudentId;
-		},
 		datumPruefungFormatted() {
 			if(!this.data.pruefungsdatum)
 				return '';
@@ -58,13 +49,12 @@ export default {
 	},
 	methods: {
 		load() {
-			return axios.get(
+			return this.$fhcApi.factory
-				FHC_JS_DATA_STORAGE_OBJECT.app_root +
+				.studstatus.wiederholung.getDetails(
-				FHC_JS_DATA_STORAGE_OBJECT.ci_router +
+					this.prestudentId
-				this.loadUrl
+				)
-			).then(
+				.then(result => {
-				result => {
+					this.data = result.data;
-					this.data = result.data.retval;
 					if (!this.data.status || this.data.status == 'ErsteAufforderungVersandt' || this.data.status == 'ZweiteAufforderungVersandt') {
 						this.data.status = 'Offen';
 						this.data.statustyp = this.$p.t('studierendenantrag', 'status_open');
@@ -79,8 +69,7 @@ export default {
 						severity: this.statusSeverity
 					});
 					return result;
-				}
+				});
-			);
 		},
 		createAntrag() {
 			this.createAntragWithStatus(true);
@@ -89,7 +78,7 @@ export default {
 			this.createAntragWithStatus(false);
 		},
 		createAntragWithStatus(repeat) {
-			let func = repeat ? 'createAntrag' : 'cancelAntrag';
+			let func = repeat ? 'create' : 'cancel';
 			let nextState = repeat ? 'Erstellt' : 'Verzichtet';
 
 			this.$emit('setStatus', {
@@ -97,54 +86,36 @@ export default {
 				severity: 'warning'
 			});
 			this.saving = true;
-			for(var k in this.errors)
-				this.errors[k] = [];
 
-			axios.post(
+			this.$refs.form.factory
-				FHC_JS_DATA_STORAGE_OBJECT.app_root +
+				.studstatus.wiederholung[func](
-				FHC_JS_DATA_STORAGE_OBJECT.ci_router +
+					this.data.prestudent_id,
-				'/components/Antrag/Wiederholung/' + func + '/',
+					this.data.studiensemester_kurzbz
-				{
+				)
-					prestudent_id: this.data.prestudent_id,
+				.then(result => {
-					studiensemester: this.data.studiensemester_kurzbz
+					if (result.data === true)
-				}
+						document.location += "";
-			).then(
+
-				result => {
+					this.data = result.data;
-					if (result.data.error)
+					if (!this.data.status)
-					{
+						this.data.status = nextState;
-						for (var k in result.data.retval)
+					this.$emit('update:status', this.data.status);
-						{
+					this.$emit("setStatus", {
-							if (this.errors[k] !== undefined)
+						msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.data.statustyp})),
-								this.errors[k].push(result.data.retval[k]);
+						severity: this.statusSeverity
-							else
+					});
-								this.errors.default.push(result.data.retval[k]);
-						}
-						this.$emit('setStatus', {
-							msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.$p.t('studierendenantrag', 'status_error')})),
-							severity: 'danger'
-						});
-					}
-					else
-					{
-						if (result.data.retval === true)
-							document.location += "";
-						this.data = result.data.retval;
-						if (!this.data.status)
-							this.data.status = nextState;
-						this.$emit('update:status', this.data.status);
-						this.$emit("setStatus", {
-							msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.data.statustyp})),
-							severity: this.statusSeverity
-						});
-					}
 					this.saving = false;
-				}
+				})
-			);
+				.catch(error => {
+					this.$emit('setStatus', {
+						msg: Vue.computed(() => this.$p.t('studierendenantrag', 'status_x', {status: this.$p.t('studierendenantrag', 'status_error')})),
+						severity: 'danger'
+					});
+					this.saving = false;
+					this.$fhcAlert.handleSystemError(error);
+				});
 		}
 	},
-	created() {
-		this.uuid = _uuid++;
-	},
 	mounted() {
 		this.infos = [...Array(5).keys()].map(n => ({
 			body: Vue.computed(() => this.$p.t('studierendenantrag', 'infotext_Wiederholung_' + n))
@@ -154,10 +125,9 @@ export default {
 	template: `
 	<div class="studierendenantrag-form-wiederholung">
 		<core-fetch-cmpt :api-function="load">
-			<div class="row">
+			<core-form ref="form" class="row">
 				<div class="col-12">
-					<div v-for="error in errors.default" class="alert alert-danger" role="alert" v-html="error">
+					<form-validation></form-validation>
-					</div>
 					<table class="table">
 						<tr>
 							<th>{{$p.t('lehre', 'studiengang')}}</th>
@@ -206,7 +176,7 @@ export default {
 						{{$p.t('studierendenantrag/antrag_Wiederholung_button_no')}}
 					</button>-->
 				</div>
-			</div>
+			</core-form>
 			<template v-slot:error="{errorMessage}">
 				<div class="alert alert-danger m-0" role="alert">
 					{{ errorMessage }}

public/js/components/Studierendenantrag/Leitung.js

@@ -39,15 +39,10 @@ export default {
 	},
 	methods: {
 		loadFilter() {
-			axios.get(
+			this.$fhcApi.factory
-				FHC_JS_DATA_STORAGE_OBJECT.app_root +
+				.studstatus.leitung.getStgs()
-				FHC_JS_DATA_STORAGE_OBJECT.ci_router +
+				.then(result => this.stgs = result.data)
-				'/components/Antrag/Leitung/getActiveStgs'
+				.catch(this.$fhcAlert.handleSystemError);
-			).then(result => {
-				this.stgs = result.data.retval;
-			}).catch(error => {
-				console.error(error);
-			});
 		},
 		changeFilter(filter) {
 			this.filter = filter || undefined;
@@ -103,21 +98,9 @@ export default {
 				}
 			} else {
 				this.$refs.loader.show();
-				axios
+				this.$fhcApi.factory
-					.all(
+					.studstatus.leitung.approve(oks)
-						oks.map(
+					.then(this.showResults);
-							antrag => axios.post(
-								FHC_JS_DATA_STORAGE_OBJECT.app_root +
-								FHC_JS_DATA_STORAGE_OBJECT.ci_router +
-								'/components/Antrag/Leitung/approve' + antrag.typ,
-								{
-									studierendenantrag_id: antrag.studierendenantrag_id
-								}
-							)
-						)
-					)
-					.then(this.showValidation)
-					.catch(this.showError);
 			}
 		},
 		actionReject(evt, gruende) {
@@ -147,99 +130,38 @@ export default {
 					.catch(() => {});
 			} else {
 				this.$refs.loader.show();
-				axios
+				this.$fhcApi.factory
-					.all(
+					.studstatus.leitung.reject(gruende)
-						gruende.map(
+					.then(this.showResults);
-							antrag => axios.post(
-								FHC_JS_DATA_STORAGE_OBJECT.app_root +
-								FHC_JS_DATA_STORAGE_OBJECT.ci_router +
-								'/components/Antrag/Leitung/reject' + antrag.typ,
-								{
-									studierendenantrag_id: antrag.studierendenantrag_id,
-									grund: antrag.grund
-								}
-							)
-						)
-					)
-					.then(this.showValidation)
-					.catch(this.showError);
 			}
 		},
 		actionReopen(evt) {
 			var antraege = evt || this.selectedData;
 			this.$refs.loader.show();
-			axios
+			this.$fhcApi.factory
-				.all(
+				.studstatus.leitung.reopen(gruende)
-					antraege.map(
+				.then(this.showResults);
-						antrag => axios.post(
-							FHC_JS_DATA_STORAGE_OBJECT.app_root +
-							FHC_JS_DATA_STORAGE_OBJECT.ci_router +
-							'/components/Antrag/Leitung/reopenAntrag/',
-							{
-								studierendenantrag_id: antrag.studierendenantrag_id
-							}
-						)
-					)
-				)
-				.then(this.showValidation)
-				.catch(this.showError);
 		},
 		actionPause(evt) {
 			var antraege = evt || this.selectedData;
 			this.$refs.loader.show();
-			axios
+			this.$fhcApi.factory
-				.all(
+				.studstatus.leitung.pause(antraege)
-					antraege.map(
+				.then(this.showResults);
-						antrag => axios.post(
-							FHC_JS_DATA_STORAGE_OBJECT.app_root +
-							FHC_JS_DATA_STORAGE_OBJECT.ci_router +
-							'/components/Antrag/Leitung/pauseAntrag/',
-							{
-								studierendenantrag_id: antrag.studierendenantrag_id
-							}
-						)
-					)
-				)
-				.then(this.showValidation)
-				.catch(this.showError);
 		},
 		actionUnpause(evt) {
 			var antraege = evt || this.selectedData;
 			this.$refs.loader.show();
-			axios
+			this.$fhcApi.factory
-				.all(
+				.studstatus.leitung.unpause(antraege)
-					antraege.map(
+				.then(this.showResults);
-						antrag => axios.post(
-							FHC_JS_DATA_STORAGE_OBJECT.app_root +
-							FHC_JS_DATA_STORAGE_OBJECT.ci_router +
-							'/components/Antrag/Leitung/unpauseAntrag/',
-							{
-								studierendenantrag_id: antrag.studierendenantrag_id
-							}
-						)
-					)
-				)
-				.then(this.showValidation)
-				.catch(this.showError);
 		},
 		actionObject(evt) {
 			var antraege = evt || this.selectedData;
 			this.$refs.loader.show();
-			axios
+			this.$fhcApi.factory
-				.all(
+				.studstatus.leitung.object(antraege)
-					antraege.map(
+				.then(this.showResults);
-						antrag => axios.post(
-							FHC_JS_DATA_STORAGE_OBJECT.app_root +
-							FHC_JS_DATA_STORAGE_OBJECT.ci_router +
-							'/components/Antrag/Leitung/objectAntrag/',
-							{
-								studierendenantrag_id: antrag.studierendenantrag_id
-							}
-						)
-					)
-				)
-				.then(this.showValidation)
-				.catch(this.showError);
 		},
 		actionoObjectionDeny(evt, gruende) {
 			var antraege = evt || this.selectedData;
@@ -267,84 +189,31 @@ export default {
 					.catch(() => {});
 			} else {
 				this.$refs.loader.show();
-				axios
+				this.$fhcApi.factory
-					.all(
+					.studstatus.leitung.denyObjection(gruende)
-						gruende.map(
+					.then(this.showResults);
-							antrag => axios.post(
-								FHC_JS_DATA_STORAGE_OBJECT.app_root +
-								FHC_JS_DATA_STORAGE_OBJECT.ci_router +
-								'/components/Antrag/Leitung/objectionDeny/',
-								{
-									studierendenantrag_id: antrag.studierendenantrag_id,
-									grund: antrag.grund
-								}
-							)
-						)
-					)
-					.then(this.showValidation)
-					.catch(this.showError);
 			}
 		},
 		actionObjectionApprove(evt, gruende) {
 			var antraege = evt || this.selectedData;
 			this.$refs.loader.show();
-			axios
+			this.$fhcApi.factory
-				.all(
+				.studstatus.leitung.approveObjection(antraege)
-					antraege.map(
+				.then(this.showResults);
-						antrag => axios.post(
-							FHC_JS_DATA_STORAGE_OBJECT.app_root +
-							FHC_JS_DATA_STORAGE_OBJECT.ci_router +
-							'/components/Antrag/Leitung/objectionApprove/',
-							{
-								studierendenantrag_id: antrag.studierendenantrag_id
-							}
-						)
-					)
-				)
-				.then(this.showValidation)
-				.catch(this.showError);
 		},
 		actionCancel(evt) {
 			var antraege = evt || this.selectedData;
 			this.$refs.loader.show();
-			axios
+			this.$fhcApi.factory
-				.all(
+				.studstatus.abmeldung.cancel(antraege)
-					antraege.map(
+				.then(this.showResults);
-						antrag => axios.post(
-							FHC_JS_DATA_STORAGE_OBJECT.app_root +
-							FHC_JS_DATA_STORAGE_OBJECT.ci_router +
-							'/components/Antrag/Abmeldung/cancelAntrag/',
-							{
-								antrag_id: antrag.studierendenantrag_id
-							}
-						)
-					)
-				)
-				.then(this.showValidation)
-				.catch(this.showError);
 		},
-		showValidation(results) {
+		showResults(results) {
-			var errors = results.filter(res => res.data.error);
+			let fulfilled = results.filter(res => res.status == 'fulfilled');
 			this.$refs.loader.hide();
-			if (errors.length) {
+			//fulfilled.forEach(a => this.$fhcAlert.alertDefault('success', '#' + a.value.data, 'Approved, ...'));
-				let errorMsg = errors.map(
+			if (fulfilled.length)
-					error =>
+				this.reload();
-					'Antrag ' +
-					JSON.parse(error.config.data).studierendenantrag_id +
-					'\n' +
-					Object.values(error.data.retval).join('\n')
-				).join('\n');
-
-				BsAlert.popup(errorMsg, {dialogClass: 'alert alert-danger'});
-			}
-			this.reload();
-		},
-		showError(error) {
-			this.$refs.loader.hide();
-			let msg = error.response.data;
-			if (msg.replace(/^\s+/, '').substr(0, 9) == '<!DOCTYPE' || msg.replace(/^\s+/, '').substr(0, 4).toLowerCase() == '<div')
-				msg = error.message;
-			BsAlert.popup(msg, {dialogClass: 'alert alert-danger'});
 		}
 	},
 	created() {

public/js/components/Studierendenantrag/Leitung/Actions/New.js

@@ -35,28 +35,32 @@ export default {
 			});
 		},
 		loadData(evt) {
-			if (this.abortController)
+                        if( evt.query.length < 2 )
-				this.abortController.abort();
+                        {
+                            return false;
+                        }
+
+			if (this.abortController instanceof AbortController
+                            && this.abortController.signal.aborted === false)
+                        {
+                            this.abortController.abort();
+                        }
 			this.abortController = new AbortController();
 
-			axios.post(
+			this.$fhcApi.factory
-				FHC_JS_DATA_STORAGE_OBJECT.app_root +
+				.studstatus.leitung.getPrestudents(evt.query, this.abortController.signal)
-				FHC_JS_DATA_STORAGE_OBJECT.ci_router +
+				.then(result => {
-				'/components/Antrag/Abmeldung/getStudiengaengeAssistenz/',
+					this.data = result.data;
-				evt,
+                                        this.abortController = null;
-				{
+				})
-					signal: this.abortController.signal
+				.catch(error => {
-				}
+                                    if (this.abortController instanceof AbortController 
-			).then(
+                                        && this.abortController.signal.aborted === false)
-				result => {
+                                    {
-					if (result.data.error) {
+                                        this.abortController.abort();
-						BsAlert.popup(result.data.retval, {dialogClass: 'alert alert-danger'});
+                                    }
-					} else {
+                                    this.$fhcAlert.handleSystemError(error);
-						this.data = result.data.retval;
+                                });
-					}
-					return result;
-				}
-			).catch(() => {});
 		}
 	},
 	template: `
@@ -79,15 +83,20 @@ export default {
 								class="w-100"
 								v-model="student"
 								:suggestions="data"
-								optionLabel = "name"
+								option-label = "name"
 								@complete="loadData"
-								inputId="newAntragModalAutoComplete"
+								input-id="newAntragModalAutoComplete"
 								dropdown
 								dropdown-mode="current"
 								>
 								<template #option="slotProps">
 									<div :title="slotProps.option.prestudent_id">
-									{{slotProps.option.name}}
+										{{slotProps.option.name}}
+									</div>
+								</template>
+								<template #empty>
+									<div class="text-muted px-3 py-2">
+										{{ $p.t('ui/keineEintraegeGefunden') }}
 									</div>
 								</template>
 							</auto-complete>

public/js/components/Studierendenantrag/Leitung/LvPopup.js

@@ -36,21 +36,17 @@ export default {
 	},
 	methods: {
 		setlvs(param) {
-			if(param.error) {
+			this.repeat_last = !!param.repeat_last;
-				this.$refs.fetchCompt.error = true;
+			if (this.repeat_last) {
-				this.$refs.fetchCompt.errorMessage = param.retval;
+				delete param.repeat_last;
-			} else {
-				this.repeat_last = !!param.retval.repeat_last;
-				if (this.repeat_last) {
-					delete param.retval.repeat_last;
-				}
-				this.lvs = param.retval;
 			}
+			this.lvs = param;
 		},
 		loadlvs() {
 			if (!this.antragId)
 				return new Promise(() => {});
-			return axios.get(FHC_JS_DATA_STORAGE_OBJECT.app_root + FHC_JS_DATA_STORAGE_OBJECT.ci_router + '/components/Antrag/Wiederholung/getLvs/' + this.antragId);
+			return this.$fhcApi.factory
+				.studstatus.wiederholung.getLvs(this.antragId);
 		},
 		submit(result) {
 			this.result = [result, this.check];

public/js/components/Studierendenantrag/Leitung/Table.js

@@ -31,9 +31,6 @@ export default {
 	],
 	data() {
 		return {
-			ajaxUrl: FHC_JS_DATA_STORAGE_OBJECT.app_root +
-				FHC_JS_DATA_STORAGE_OBJECT.ci_router +
-				'/components/Antrag/Leitung/getAntraege/',
 			table: null,
 			lastHistoryClickedId: null,
 			historyData: [],
@@ -42,7 +39,7 @@ export default {
 	},
 	methods: {
 		reload(stg) {
-			this.table.setData(this.ajaxUrl + (stg || ''));
+			this.table.setData('/' + (stg || ''));
 		},
 		download() {
 			this.table.download("csv", "data.csv", {
@@ -53,14 +50,12 @@ export default {
 		getHistory() {
 			if (this.lastHistoryClickedId === null)
 				return null;
-			return axios.get(
+			return this.$fhcApi.factory
-				FHC_JS_DATA_STORAGE_OBJECT.app_root +
+				.studstatus.leitung.getHistory(this.lastHistoryClickedId)
-				FHC_JS_DATA_STORAGE_OBJECT.ci_router +
+				.then(res => {
-				'/components/Antrag/Leitung/getHistory/' +
+					this.historyData = res.data.sort((a, b) => a.insertamum > b.insertamum);
-				this.lastHistoryClickedId
+				})
-			).then(res => {
+				.catch(this.$fhcApi.handleSystemError);
-				this.historyData = res.data.retval.sort((a, b) => a.insertamum > b.insertamum);
-			});
 		},
 		getHistoryStatus(data, index) {
 			if (data.insertvon == 'Studienabbruch')
@@ -116,7 +111,8 @@ export default {
 			movableColumns: true,
 			height: '65vh',
 			layout: "fitDataFill",
-			ajaxURL: this.ajaxUrl + (this.filter || ''),
+			ajaxURL: '/' + (this.filter || ''),
+			ajaxRequestFunc: this.$fhcApi.factory.studstatus.leitung.getAntraege,
 			persistence: { // NOTE(chris): do not store column titles
 				sort: true, //persist column sorting
 				filter: true, //persist filters
@@ -269,7 +265,7 @@ export default {
 							allowed_status_for_download = ['Genehmigt'];
 							break;
 						case 'AbmeldungStgl':
-							allowed_status_for_download = ['Genehmigt', 'Beeinsprucht', 'EinspruchAbgelehnt', 'Abgemeldet'];
+							allowed_status_for_download = ['EinspruchAbgelehnt', 'Abgemeldet'];
 							break;
 						case 'Unterbrechung':
 							allowed_status_for_download = ['Genehmigt', 'EmailVersandt'];

public/js/components/Studierendenantrag/Lvzuweisung.js

@@ -56,39 +56,19 @@ export default {
 				anmerkung: lv.antrag_anmerkung || "",
 				studiensemester_kurzbz: this.lvs2sem
 			}));
-			axios.post(FHC_JS_DATA_STORAGE_OBJECT.app_root + FHC_JS_DATA_STORAGE_OBJECT.ci_router + '/components/Antrag/Wiederholung/saveLvs/', {forbiddenLvs, mandatoryLvs})
+			this.$fhcApi.factory
+				.studstatus.wiederholung.saveLvs(forbiddenLvs, mandatoryLvs)
 				.then(response => {
-					if(!response.data.error) {
+					this.$fhcAlert.alertSuccess('Speichern erfolgreich');
-						this.addAlert('Speichern erfolgreich', 'alert-success');
+					this.statusCode = response.data[0].studierendenantrag_statustyp_kurzbz;
-						this.statusCode = response.data.retval[0].studierendenantrag_statustyp_kurzbz;
+					this.statusMsg = response.data[0].typ;
-						this.statusMsg = response.data.retval[0].typ;
-					} else {
-						this.addAlert(response.data.retval.message || response.data.retval, 'alert-danger');
-						this.statusCode = 0;
-						this.statusMsg = 'Error';
-					}
 					this.isloading = false;
-				}).catch(error => {
+				})
-					this.addAlert(error.message, 'alert-danger');
+				.catch(error => {
 					this.statusCode = 0;
 					this.statusMsg = 'Error';
 					this.isloading = false;
-				}).finally(() => {
-					window.scrollTo(0, 0);
 				});
-		},
-		addAlert(text, type) {
-			const para = document.createElement("p");
-			para.innerText = text;
-			para.className = "alert " + type + " alert-dismissible fade show";
-			const btn =  document.createElement("button");
-			btn.className = "btn-close";
-			btn.type = "button";
-			btn.setAttribute("aria-label", "Close");
-			btn.setAttribute("data-bs-dismiss", "alert");
-			para.appendChild(btn);
-
-			this.$refs.alertbox.appendChild(para);
 		}
 	},
 	created() {
@@ -96,149 +76,141 @@ export default {
 		this.statusMsg = this.initialStatusMsg;
 	},
 	mounted() {
-		axios.get(FHC_JS_DATA_STORAGE_OBJECT.app_root + FHC_JS_DATA_STORAGE_OBJECT.ci_router + '/components/Antrag/Wiederholung/getLvs/' + this.antragId).then(
+		this.$p
-			result => {
+			.loadCategory(['ui', 'lehre', 'studierendenantrag', 'global'])
-				if(result.data.error)
+			.then(() => this.antragId)
-				{
+			.then(this.$fhcApi.factory.studstatus.wiederholung.getLvs)
-					this.addAlert(result.data.retval, 'alert-danger');
+			.then(result => {
-					this.isloading = true;
+				let res = {};
-				}
+				for (var k in result.data) {
-				else
+					if (k === 'repeat_last')
-				{
+						continue;
-					let res = {};
+					if (result.data[k] === null) {
-					this.$p
+						const alert = document.createElement('div');
-						.loadCategory(['ui', 'lehre', 'studierendenantrag', 'global'])
+						alert.innerHTML = this.$p.t('studierendenantrag', 'error_stg_last_semester');
-						.then(() => {
+						alert.className = 'alert alert-warning';
-							for (var k in result.data.retval) {
+						alert.role = 'alert';
-								if (k === 'repeat_last')
+						this.$refs["lvtable" + k.substr(0,1)].append(alert);
-									continue;
+						continue;
-								if (result.data.retval[k] === null) {
+					}
-									const alert = document.createElement('div');
+					let lvs = result.data[k].reduce((obj,lv) => {
-									alert.innerHTML = this.$p.t('studierendenantrag', 'error_stg_last_semester');
+						obj[lv.studienplan_lehrveranstaltung_id] = lv;
-									alert.className = 'alert alert-warning';
+						return obj;
-									alert.role = 'alert';
+					}, {});
-									this.$refs["lvtable" + k.substr(0,1)].append(alert);
+					for (var lv of Object.values(lvs)) {
-									continue;
+						if (!lv.studienplan_lehrveranstaltung_id_parent)
+							continue;
+						if (!lvs[lv.studienplan_lehrveranstaltung_id_parent])
+							console.error('parent not available');
+						else {
+							if (!lvs[lv.studienplan_lehrveranstaltung_id_parent]._children)
+								lvs[lv.studienplan_lehrveranstaltung_id_parent]._children = [];
+							lvs[lv.studienplan_lehrveranstaltung_id_parent]._children.push(lv);
+						}
+					}
+					res[k] = Object.values(lvs).filter(lv => !lv.studienplan_lehrveranstaltung_id_parent);
+					let current = res[k];
+					let index = k.substr(0,1);
+
+					const options = {
+						data: current,
+						dataTree: true,
+						dataTreeStartExpanded: true, //start with an expanded tree
+						dataTreeChildIndent: 15,
+						layout: "fitDataStretch",
+						columns: [
+							{title: this.$p.t('ui', 'bezeichnung'), field: "bezeichnung"},
+							{title: this.$p.t('lehre','lehrform'), field: "lehrform_kurzbz"},
+							{title: "ECTS", field: "ects"},
+							{title: this.$p.t('lehre','note'), field: "note", formatter:(cell, formatterParams, onRendered) => cell.getValue() || "---"},
+							{
+								title: index == 1 && !result.data.repeat_last ? this.$p.t('studierendenantrag','lv_nicht_zulassen') : this.$p.t('studierendenantrag','lv_wiederholen'),
+								field: "antrag_zugelassen",
+								formatter: (cell, formatterParams, onRendered) => {
+									let data = cell.getData();
+									if (data._children || !data.zeugnis)
+										return "";
+									let input = document.createElement('input');
+									input.className = "form-check-input";
+									input.type = "checkbox";
+									input.role = "switch";
+									input.checked = cell.getValue();
+									input.addEventListener('input', () => {
+										lvs[data.studienplan_lehrveranstaltung_id].antrag_zugelassen = input.checked;
+										cell.getRow().reformat();
+									});
+									if (this.disabled) {
+										input.disabled = true;
+									}
+
+									let div =  document.createElement('div');
+									div.className = 'form-check form-switch';
+									div.append(input);
+
+									return div;
 								}
-								let lvs = result.data.retval[k].reduce((obj,lv) => {
+							},
-									obj[lv.studienplan_lehrveranstaltung_id] = lv;
+							{
-									return obj;
+								title: this.$p.t('global','anmerkung'),
-								}, {});
+								field: "antrag_anmerkung",
-								for (var lv of Object.values(lvs)) {
+								headerSort:false,
-									if (!lv.studienplan_lehrveranstaltung_id_parent)
+								titleFormatter:(cell, formatterParams, onRendered)=>{
-										continue;
+									let link =  document.createElement('a');
-									if (!lvs[lv.studienplan_lehrveranstaltung_id_parent])
+									link.addEventListener('click', (e) => {
-										console.error('parent not available');
+										e.preventDefault();
-									else {
+									});
-										if (!lvs[lv.studienplan_lehrveranstaltung_id_parent]._children)
+
-											lvs[lv.studienplan_lehrveranstaltung_id_parent]._children = [];
+									link.href ="#";
-										lvs[lv.studienplan_lehrveranstaltung_id_parent]._children.push(lv);
+									link.title = this.$p.t('studierendenantrag','anmerkung_tooltip');
+									new bootstrap.Tooltip(link);
+									let tooltip = document.createElement('span');
+									tooltip.innerHTML = this.$p.t('global','anmerkung') + " ";
+									tooltip.append(link);
+
+									let icon =  document.createElement('i');
+									link.append(icon);
+									icon.className = "fa fa-info-circle";
+									icon.setAttribute("aria-hidden", "true");
+									icon.style.minWidth = '1em';
+
+									return tooltip;
+
+								},
+								formatter: (cell, formatterParams, onRendered) => {
+									if (this.disabled) {
+										return cell.getValue() || "";
+									}
+									var data = cell.getData();
+									if (lvs[data.studienplan_lehrveranstaltung_id].antrag_zugelassen)
+									{
+										let input = document.createElement('input');
+										input.className = "form-control";
+										input.type = "text";
+										input.value = cell.getValue() || "";
+										input.addEventListener('input', () => {
+											lvs[data.studienplan_lehrveranstaltung_id].antrag_anmerkung = input.value;
+										});
+										return input;
+									}
+									else
+									{
+										return "";
 									}
 								}
-								res[k] = Object.values(lvs).filter(lv => !lv.studienplan_lehrveranstaltung_id_parent);
-								let current = res[k];
-								let index = k.substr(0,1);
-
-								const options = {
-									data: current,
-									dataTree: true,
-									dataTreeStartExpanded: true, //start with an expanded tree
-									dataTreeChildIndent: 15,
-									layout: "fitDataStretch",
-									columns: [
-										{title: this.$p.t('ui', 'bezeichnung'), field: "bezeichnung"},
-										{title: this.$p.t('lehre','lehrform'), field: "lehrform_kurzbz"},
-										{title: "ECTS", field: "ects"},
-										{title: this.$p.t('lehre','note'), field: "note", formatter:(cell, formatterParams, onRendered)=>cell.getValue() || "---"},
-										{
-											title: index == 1 && !result.data.retval.repeat_last ? this.$p.t('studierendenantrag','lv_nicht_zulassen') : this.$p.t('studierendenantrag','lv_wiederholen'),
-											field: "antrag_zugelassen",
-											formatter: (cell, formatterParams, onRendered) => {
-												let data = cell.getData();
-												if(data._children || !data.zeugnis)
-													return "";
-												let input = document.createElement('input');
-												input.className = "form-check-input";
-												input.type = "checkbox";
-												input.role = "switch";
-												input.checked = cell.getValue();
-												input.addEventListener('input', () => {
-													lvs[data.studienplan_lehrveranstaltung_id].antrag_zugelassen = input.checked;
-													cell.getRow().reformat();
-												});
-												if (this.disabled) {
-													input.disabled = true;
-												}
-
-												let div =  document.createElement('div');
-												div.className = 'form-check form-switch';
-												div.append(input);
-
-												return div;
-											}
-										},
-										{
-											title: this.$p.t('global','anmerkung'),
-											field: "antrag_anmerkung",
-											headerSort:false,
-											titleFormatter:(cell, formatterParams, onRendered)=>{
-												let link =  document.createElement('a');
-												link.addEventListener('click', (e) => {
-													e.preventDefault();
-												});
-
-												link.href ="#";
-												link.title = this.$p.t('studierendenantrag','anmerkung_tooltip');
-												new bootstrap.Tooltip(link);
-												let tooltip = document.createElement('span');
-												tooltip.innerHTML = this.$p.t('global','anmerkung') + " ";
-												tooltip.append(link);
-
-												let icon =  document.createElement('i');
-												link.append(icon);
-												icon.className = "fa fa-info-circle";
-												icon.setAttribute("aria-hidden", "true");
-												icon.style.minWidth = '1em';
-
-												return tooltip;
-
-											},
-											formatter: (cell, formatterParams, onRendered) => {
-												if (this.disabled) {
-													return cell.getValue() || "";
-												}
-												var data = cell.getData();
-												if (lvs[data.studienplan_lehrveranstaltung_id].antrag_zugelassen)
-												{
-													let input = document.createElement('input');
-													input.className = "form-control";
-													input.type = "text";
-													input.value = cell.getValue() || "";
-													input.addEventListener('input', () => {
-														lvs[data.studienplan_lehrveranstaltung_id].antrag_anmerkung = input.value;
-													});
-													return input;
-												}
-												else
-												{
-													return "";
-												}
-											}
-										}
-									]
-								};
-								var table = new Tabulator(this.$refs["lvtable" + k.substr(0,1)], options);
 							}
-							this.lvs = result.data.retval;
+						]
-						});
+					};
+					var table = new Tabulator(this.$refs["lvtable" + k.substr(0,1)], options);
 				}
-			}
+				this.lvs = result.data;
-		);
+			})
+			.catch(error => {
+				this.$fhcAlert.handleSystemError(error);
+				this.isloading = true;
+			});
 	},
 	template: `
 	<div class="col-sm-10">
-		<div ref="alertbox"></div>
-
 		<span class="d-flex justify-content-between h4">
 			<span>{{lvs.repeat_last ? $p.t('studierendenantrag', 'title_lv_wiederholen') : $p.t('studierendenantrag', 'title_lv_nicht_zugelassen')}}</span>
 			<span>{{lvs1sem}}</span>

public/js/components/Tabs.js

@@ -1,4 +1,3 @@
-import {CoreRESTClient} from '../RESTClient.js';
 import accessibility from "../directives/accessibility.js";
 
 export default {
@@ -12,7 +11,7 @@ export default {
 	],
 	props: {
 		config: {
-			type: [String, Object],
+			type: [String, Array, Object, Promise],
 			required: true
 		},
 		default: String,
@@ -56,40 +55,37 @@ export default {
 		initConfig(config) {
 			if (!config)
 				return;
+			if (config instanceof Promise)
+				return config
+					.then(result => result.data)
+					.then(this.initConfig)
+					.catch(this.$fhcAlert.handleSystemError);
 			if (typeof config === 'string' || config instanceof String)
-				return CoreRESTClient.get(config)
+				return this.$fhcApi
-					.then(result => CoreRESTClient.getData(result.data))
+					.get(config)
+					.then(result => result.data)
 					.then(this.initConfig)
 					.catch(this.$fhcAlert.handleSystemError);
 
 			const tabs = {};
 
-			if (Array.isArray(config)) {
+			function _addToTabs(key, item) {
-				config.forEach((item, key) => {
+				if (!item.component)
-					if (!item.component)
+					return console.error('Component missing for ' + key);
-						return console.error('Component missing for ' + key);
 
-					tabs[key] = {
+				tabs[key] = {
-						component: Vue.markRaw(Vue.defineAsyncComponent(() => import(item.component))),
+					component: Vue.markRaw(Vue.defineAsyncComponent(() => import(item.component))),
-						title: item.title || key,
+					title: Vue.computed(() => item.title || key),
-						config: item.config,
+					config: item.config,
-						key
+					key
-					}
+				}
-				});
-			} else {
-				Object.entries(config).forEach(([key, item]) => {
-					if (!item.component)
-						return console.error('Component missing for ' + key);
-
-					tabs[key] = {
-						component: Vue.markRaw(Vue.defineAsyncComponent(() => import(item.component))),
-						title: item.title || key,
-						config: item.config,
-						key
-					}
-				});
 			}
 
+			if (Array.isArray(config))
+				config.forEach((item, key) => _addToTabs(key, item));
+			else
+				Object.entries(config).forEach(([key, item]) => _addToTabs(key, item));
+
 			if (this.current === null || !tabs[this.current]) {
 				if (tabs[this.default])
 					this.current = this.default;

public/js/components/filter/API.js

@@ -17,11 +17,11 @@
 
 import {CoreRESTClient} from '../../RESTClient.js';
 
-// 
+//
 const CORE_FILTER_CMPT_TIMEOUT = 7000;
 
 /**
- *
+ * TODO(chris): deprecated
  */
 export const CoreFilterAPIs = {
 	/**

public/js/components/filter/Filter.js

@@ -15,8 +15,6 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-import {CoreFilterAPIs} from './API.js';
-import {CoreRESTClient} from '../../RESTClient.js';
 import {CoreFetchCmpt} from '../../components/Fetch.js';
 import FilterConfig from './Filter/Config.js';
 import FilterColumns from './Filter/Columns.js';
@@ -64,7 +62,11 @@ export const CoreFilterCmpt = {
 		newBtnShow: Boolean,
 		newBtnClass: [String, Array, Object],
 		newBtnDisabled: Boolean,
-		newBtnLabel: String
+		newBtnLabel: String,
+		uniqueId: String,
+		// TODO soll im master kommen?
+		idField: String,
+		parentIdField: String
 	},
 	data: function() {
 		return {
@@ -211,6 +213,13 @@ export const CoreFilterCmpt = {
 
 			if (tabulatorOptions.columns && tabulatorOptions.columns.filter(el => el.formatter == 'rowSelection').length)
 				this.tabulatorHasSelector = true;
+			// TODO check ob im core bleiben soll
+			if (this.idField) {
+				// enable nested tabulator if parent Id given
+				if (this.parentIdField) tabulatorOptions.dataTree = true;
+				// set tabulator index
+				tabulatorOptions.index = this.idField;
+			}
 
 			// Start the tabulator with the build options
 			this.tabulator = new Tabulator(
@@ -228,6 +237,33 @@ export const CoreFilterCmpt = {
 			this.tabulator.on("rowSelectionChanged", data => {
 				this.selectedData = data;
 			});
+			// TODO check ob im core so bleiben soll
+			// if nested tabulator, restructure data
+			if (this.parentIdField && this.idField) {
+				this.tabulator.on("dataLoading", data => {
+					let toDelete = [];
+
+					// loop through all data
+					for (let childIdx = 0; childIdx < data.length; childIdx++)
+					{
+						let child = data[childIdx];
+
+						// if it has parent id, it is a child
+						if (child[this.parentIdField])
+						{
+							// append the child on the right place. If parent found, mark original sw child on 0 level for deleting
+							if (this.appendChild(data, child)) toDelete.push(childIdx);
+						}
+					}
+
+					// delete the marked children from 0 level
+					for (let counter = 0; counter < toDelete.length; counter++)
+					{
+						// decrease index by counter as index of data array changes after every deletion
+						data.splice(toDelete[counter] - counter, 1);
+					}
+				});
+			}
 			if (this.tableOnly) {
 				this.tabulator.on('tableBuilt', () => {
 					const cols = this.tabulator.getColumns();
@@ -252,12 +288,12 @@ export const CoreFilterCmpt = {
 		/**
 		 *
 		 */
-		getFilter: function() {
+		getFilter() {
 			if (this.selectedFilter === null)
-				this.startFetchCmpt(CoreFilterAPIs.getFilter, null, this.render);
+				this.startFetchCmpt(this.$fhcApi.factory.filter.getFilter, null, this.render);
 			else
 				this.startFetchCmpt(
-					CoreFilterAPIs.getFilterById,
+					this.$fhcApi.factory.filter.getFilterById,
 					{
 						filterId: this.selectedFilter
 					},
@@ -267,55 +303,47 @@ export const CoreFilterCmpt = {
 		/**
 		 *
 		 */
-		render: function(response) {
+		render(response) {
+			let data = response;
+			this.filterName = data.filterName;
+			this.dataset = data.dataset;
+			this.datasetMetadata = data.datasetMetadata;
 
-			if (CoreRESTClient.hasData(response))
+			this.fields = data.fields;
+			this.selectedFields = data.selectedFields;
+			this.notSelectedFields = this.fields.filter(x => this.selectedFields.indexOf(x) === -1);
+			this.filterFields = [];
+
+			for (let i = 0; i < data.datasetMetadata.length; i++)
 			{
-				let data = CoreRESTClient.getData(response);
+				for (let j = 0; j < data.filters.length; j++)
-				this.filterName = data.filterName;
-				this.dataset = data.dataset;
-				this.datasetMetadata = data.datasetMetadata;
-
-				this.fields = data.fields;
-				this.selectedFields = data.selectedFields;
-				this.notSelectedFields = this.fields.filter(x => this.selectedFields.indexOf(x) === -1);
-				this.filterFields = [];
-
-				for (let i = 0; i < data.datasetMetadata.length; i++)
 				{
-					for (let j = 0; j < data.filters.length; j++)
+					if (data.datasetMetadata[i].name == data.filters[j].name)
 					{
-						if (data.datasetMetadata[i].name == data.filters[j].name)
+						let filter = data.filters[j];
-						{
+						filter.type = data.datasetMetadata[i].type;
-							let filter = data.filters[j];
-							filter.type = data.datasetMetadata[i].type;
 
-							this.filterFields.push(filter);
+						this.filterFields.push(filter);
-							//break;
+						//break;
-						}
 					}
 				}
+			}
 
-				// If the side menu is active
+			// If the side menu is active
-				if (this.sideMenu === true)
+			if (this.sideMenu === true)
-				{
-					this.setSideMenu(data);
-				}
-				else // otherwise use the dropdown in the filter options
-				{
-					this.setDropDownMenu(data);
-				}
-				this.updateTabulator();
-			}
-			else
 			{
-				console.error(CoreRESTClient.getError(response));
+				this.setSideMenu(data);
 			}
+			else // otherwise use the dropdown in the filter options
+			{
+				this.setDropDownMenu(data);
+			}
+			this.updateTabulator();
 		},
 		/**
 		 * Set the menu
 		 */
-		setSideMenu: function(data) {
+		setSideMenu(data) {
 			let filters = data.sideMenu.filters;
 			let personalFilters = data.sideMenu.personalFilters;
 			let filtersArray = [];
@@ -369,7 +397,7 @@ export const CoreFilterCmpt = {
 		/**
 		 * Set the drop down menu
 		 */
-		setDropDownMenu: function(data) {
+		setDropDownMenu(data) {
 			let filters = data.sideMenu.filters;
 			let personalFilters = data.sideMenu.personalFilters;
 			let filtersArray = [];
@@ -405,7 +433,7 @@ export const CoreFilterCmpt = {
 		/**
 		 * Used to start/refresh the FetchCmpt
 		 */
-		startFetchCmpt: function(apiFunction, apiFunctionParameters, dataFetchedCallback) {
+		startFetchCmpt(apiFunction, apiFunctionParameters, dataFetchedCallback) {
 			// Assign the function api of the FetchCmpt binded property
 			this.fetchCmptApiFunction = apiFunction;
 
@@ -416,6 +444,9 @@ export const CoreFilterCmpt = {
 			apiFunctionParameters.filterUniqueId = FHC_JS_DATA_STORAGE_OBJECT.called_path + "/" + FHC_JS_DATA_STORAGE_OBJECT.called_method;
 			apiFunctionParameters.filterType = this.filterType;
 
+			if (this.uniqueId)
+				apiFunctionParameters.filterUniqueId += '_' + this.uniqueId;
+
 			// Assign parameters to the FetchCmpt binded properties
 			this.fetchCmptApiFunctionParams = apiFunctionParameters;
 			// Assign data fetch callback to the FetchCmpt binded properties
@@ -431,11 +462,11 @@ export const CoreFilterCmpt = {
 		/**
 		 *
 		 */
-		handlerSaveCustomFilter: function(customFilterName) {
+		handlerSaveCustomFilter(customFilterName) {
 			this.selectedFilter = null;
 			//
 			this.startFetchCmpt(
-				CoreFilterAPIs.saveCustomFilter,
+				this.$fhcApi.factory.filter.saveCustomFilter,
 				{
 					customFilterName
 				},
@@ -445,13 +476,13 @@ export const CoreFilterCmpt = {
 		/**
 		 *
 		 */
-		handlerRemoveCustomFilter: function(event) {
+		handlerRemoveCustomFilter(event) {
 			let filterId = event.currentTarget.getAttribute("href").substring(1);
 			if (filterId === this.selectedFilter)
 				this.selectedFilter = null;
 			//
 			this.startFetchCmpt(
-				CoreFilterAPIs.removeCustomFilter,
+				this.$fhcApi.factory.filter.removeCustomFilter,
 				{
 					filterId: filterId
 				},
@@ -488,12 +519,42 @@ export const CoreFilterCmpt = {
 		applyFilterConfig(filterFields) {
 			this.selectedFilter = null;
 			this.startFetchCmpt(
-				CoreFilterAPIs.applyFilterFields,
+				this.$fhcApi.factory.filter.applyFilterFields,
 				{
 					filterFields
 				},
 				this.getFilter
 			);
+		},
+		// TODO check ob im core so bleiben soll
+		// append child to it's parent
+		appendChild(data, child) {
+			// get parent id
+			let parentId = child[this.parentIdField];
+
+			// loop thorugh all data
+			for (let parentIdx = 0; parentIdx < data.length; parentIdx++)
+			{
+				let parent = data[parentIdx];
+
+				// if it's the parent
+				if (parent[this.idField] == parentId)
+				{
+					// create children array if not done yet
+					if (!parent._children) parent._children = [];
+
+					// if child is not included in children array, append the child
+					if (!parent._children.includes(child)) parent._children.push(child);
+
+					// parent found
+					return true;
+				}
+				// search children for parents
+				else if (parent._children) this.appendChild(parent._children, child);
+			}
+
+			// parent not found
+			return false;
 		}
 	},
 	beforeCreate() {
@@ -522,7 +583,7 @@ export const CoreFilterCmpt = {
 
 		<div class="row" v-if="title != null && title != ''">
 			<div class="col-lg-12">
-				<h3 class="page-header">
+				<h3 class="page-header mt-1 mb-4">
 					{{ title }}
 				</h3>
 			</div>
@@ -531,7 +592,7 @@ export const CoreFilterCmpt = {
 		<div :id="'filterCollapsables' + idExtra">
 
 			<div class="d-flex flex-row justify-content-between flex-wrap">
-				<div v-if="newBtnShow || reload || $slots.actions" class="d-flex gap-2 align-items-baseline flex-wrap">
+				<div v-if="newBtnShow || reload || $slots.search || $slots.actions" class="d-flex gap-2 align-items-baseline flex-wrap">
 					<button v-if="newBtnShow" class="btn btn-primary" :class="newBtnClass" :title="newBtnLabel ? undefined : 'New'" :aria-label="newBtnLabel ? undefined : 'New'" @click="$emit('click:new', $event)" :disabled="newBtnDisabled">
 						<span class="fa-solid fa-plus" aria-hidden="true"></span>
 						{{ newBtnLabel }}
@@ -539,8 +600,9 @@ export const CoreFilterCmpt = {
 					<button v-if="reload" class="btn btn-outline-secondary" aria-label="Reload" @click="reloadTable">
 						<span class="fa-solid fa-rotate-right" aria-hidden="true"></span>
 					</button>
-					<span v-if="$slots.actions && tabulatorHasSelector">Mit {{selectedData.length}} ausgewählten: </span>
+					<span v-if="$slots.actions && tabulatorHasSelector">Mit {{selectedData.length}} ausgewählten:</span>
 					<slot name="actions" v-bind="tabulatorHasSelector ? selectedData : []"></slot>
+					<slot name="search"></slot>
 				</div>
 				<div class="d-flex gap-1 align-items-baseline flex-grow-1 justify-content-end">
 					<span v-if="!tableOnly">[ {{ filterName }} ]</span>

public/js/components/navigation/API.js

@@ -21,7 +21,7 @@ import {CoreRESTClient} from '../../RESTClient.js';
 const CORE_NAVIGATION_CMPT_TIMEOUT = 5000;
 
 /**
- *
+ * TODO(chris): deprecated
  */
 export const CoreNavigationAPIs = {
 	/**

public/js/components/navigation/Navigation.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2022 fhcomplete.org
+ * Copyright (C) 2024 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
@@ -15,8 +15,6 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-import {CoreNavigationAPIs} from './API.js';
-import {CoreRESTClient} from '../../RESTClient.js';
 import {CoreFetchCmpt} from '../../components/Fetch.js';
 
 /**
@@ -30,12 +28,12 @@ export const CoreNavigationCmpt = {
 		addHeaderMenuEntries: Object, // property used to add new header menu entries from another app/component
 		addSideMenuEntries: Object, // property used to add new side menu entries from another app/component
 		hideTopMenu: Boolean,
-                leftNavCssClasses: {
+		leftNavCssClasses: {
-                    type: String,
+			type: String,
-                    default: 'navbar navbar-left-side'
+			default: 'navbar navbar-left-side'
-                }
+		}
 	},
-	data: function() {
+	data() {
 		return {
 			headerMenu: {}, // header menu entries
 			sideMenu: {} // side menu entries
@@ -45,61 +43,63 @@ export const CoreNavigationCmpt = {
 		/**
 		 *
 		 */
-		headerMenuEntries: function() {
+		headerMenuEntries() {
 			//
+			let hm = this.headerMenu ? {...this.headerMenu} : {};
 			if (this.headerMenu != null && this.addHeaderMenuEntries != null && Object.keys(this.addHeaderMenuEntries).length > 0)
 			{
-				this.headerMenu[this.addHeaderMenuEntries.description] = this.addHeaderMenuEntries;
+				hm[this.addHeaderMenuEntries.description] = this.addHeaderMenuEntries;
 			}
-			return this.headerMenu;
+			return hm;
 		},
 		/**
 		 *
 		 */
-		sideMenuEntries: function() {
+		sideMenuEntries() {
 			//
+			let sm = this.sideMenu ? {...this.sideMenu} : {};
 			if (this.sideMenu != null && this.addSideMenuEntries != null && Object.keys(this.addSideMenuEntries).length > 0)
 			{
-				this.sideMenu[this.addSideMenuEntries.description] = this.addSideMenuEntries;
+				sm[this.addSideMenuEntries.description] = this.addSideMenuEntries;
 			}
-			return this.sideMenu;
+			return sm;
 		}
 	},
 	methods: {
 		/**
 		 *
 		 */
-		getNavigationPage: function() {
+		getNavigationPage() {
 			return FHC_JS_DATA_STORAGE_OBJECT.called_path + "/" + FHC_JS_DATA_STORAGE_OBJECT.called_method;
 		},
 		/**
 		 *
 		 */
-		fetchCmptApiFunctionHeader: function() {
+		fetchCmptApiFunctionHeader() {
-			return CoreNavigationAPIs.getHeader(this.getNavigationPage());
+			return this.$fhcApi.factory.navigation.getHeader(this.getNavigationPage());
 		},
 		/**
 		 *
 		 */
-		fetchCmptApiFunctionSideMenu: function() {
+		fetchCmptApiFunctionSideMenu() {
-			return CoreNavigationAPIs.getMenu(this.getNavigationPage());
+			return this.$fhcApi.factory.navigation.getMenu(this.getNavigationPage());
 		},
 		/**
 		 *
 		 */
-		fetchCmptDataFetchedHeader: function(data) {
+		fetchCmptDataFetchedHeader(data) {
-			if (CoreRESTClient.hasData(data)) this.headerMenu = CoreRESTClient.getData(data);
+			this.headerMenu = data || {};
 		},
 		/**
 		 *
 		 */
-		fetchCmptDataFetchedMenu: function(data) {
+		fetchCmptDataFetchedMenu(data) {
-			if (CoreRESTClient.hasData(data)) this.sideMenu = CoreRESTClient.getData(data);
+			this.sideMenu = data || {};
 		},
 		/**
 		 *
 		 */
-		getDataBsToggle: function(header) {
+		getDataBsToggle(header) {
 			return !header.children ? null : 'dropdown';
 		}
 	},

public/js/plugin/FhcAlert.js

@@ -250,6 +250,10 @@ export default {
 				// Error is array of strings
 				if (Array.isArray(error) && error.every(err => typeof err === 'string'))
 					return error.every($fhcAlert.alertSystemError);
+
+				// Error has been handled already
+				if (error.hasOwnProperty('handled') && error.handled)
+					return;
 				
 				// Error is object
 				if (typeof error === 'object' && error !== null) {

public/js/plugin/FhcApi.js

@@ -1,5 +1,5 @@
 import FhcAlert from './FhcAlert.js';
-import FhcApiFactory from '../apps/api/fhcapifactory.js';
+import FhcApiFactory from '../api/fhcapifactory.js';
 
 
 export default {
@@ -100,13 +100,13 @@ export default {
 			// NOTE(chris): loop through errors
 			if (response.data.errors)
 				response.data.errors = response.data.errors.filter(
-					err => (response.config[err.type + 'ErrorHandler'] || app.config.globalProperties.$fhcApi._defaultErrorHandlers[err.type])(err, response.config.form)
+					err => (response.config[err.type + 'ErrorHandler'] || app.config.globalProperties.$fhcApi._defaultErrorHandlers[err.type])(err, response.config)
 				);
 
 			return _clean_return_value(response);
 		}, error => {
 			if (error.code == 'ERR_CANCELED')
-				return new Promise(() => {});
+				return Promise.reject({...{handled: true}, ...error});
 			
 			if (error.config?.errorHandling == 'off'
 				|| error.config?.errorHandling === false
@@ -116,21 +116,21 @@ export default {
 			if (error.response) {
 				if (error.response.status == 404) {
 					app.config.globalProperties.$fhcAlert.alertDefault('error', error.message, error.request.responseURL, true);
-					return new Promise(() => {});
+					return Promise.reject({...{handled: true}, ...error});
 				}
 				
 				// NOTE(chris): loop through errors
 				error.response.data.errors = error.response.data.errors.filter(
-					err => (error.config[err.type + 'ErrorHandler'] || app.config.globalProperties.$fhcApi._defaultErrorHandlers[err.type])(err, error.config.form)
+					err => (error.config[err.type + 'ErrorHandler'] || app.config.globalProperties.$fhcApi._defaultErrorHandlers[err.type])(err, error.config)
 				);
 				if (!error.response.data.errors.length)
-					return new Promise(() => {});
+					return Promise.reject({...{handled: true}, ...error});
 			} else if (error.request) {
 				app.config.globalProperties.$fhcAlert.alertDefault('error', error.message, error.request.responseURL);
-				return new Promise(() => {});
+				return Promise.reject({...{handled: true}, ...error});
 			} else {
 				app.config.globalProperties.$fhcAlert.alertError(error.message);
-				return new Promise(() => {});
+				return Promise.reject({...{handled: true}, ...error});
 			}
 			
 			return Promise.reject(error);
@@ -152,30 +152,47 @@ export default {
 				return fhcApiAxios.post(uri, data, config);
 			},
 			_defaultErrorHandlers: {
-				validation(error, form) {
+				validation(error, config) {
 					const $fhcAlert = app.config.globalProperties.$fhcAlert;
 
-					if (form) {
+					if (config?.form) {
-						form.clearValidation();
+						config.form.clearValidation();
-						form.setFeedback(false, error.messages);
+						config.form.setFeedback(false, error.messages);
 						return false;
 					}
 					if (Array.isArray(error.messages)) {
 						error.messages.forEach($fhcAlert.alertError);
 						return false;
 					} else if (typeof error.messages == 'object') {
-						Object.entries(error.messages).forEach(
+						if (config?.errorHeader)
-							([key, value]) => $fhcAlert.alertDefault('error', key, value, true)
+							Object.values(error.messages).forEach(
-						);
+								value => $fhcAlert.alertDefault(
+									'error',
+									Array.isArray(config.errorHeader) ? app.config.globalProperties.$p.t.apply(null, config.errorHeader) : config.errorHeader,
+									value,
+									true
+								)
+							);
+						else
+							Object.entries(error.messages).forEach(
+								([key, value]) => $fhcAlert.alertDefault('error', key, value, true)
+							);
 						return false;
 					}
 					return true;
 				},
-				general(error, form) {
+				general(error, config) {
 					const $fhcAlert = app.config.globalProperties.$fhcAlert;
 
-					if (form)
+					if (config?.form)
-						form.setFeedback(false, error.message);
+						config.form.setFeedback(false, error.message);
+					else if (config?.errorHeader)
+						$fhcAlert.alertDefault(
+							'error',
+							Array.isArray(config.errorHeader) ? app.config.globalProperties.$p.t.apply(null, config.errorHeader) : config.errorHeader,
+							error.message,
+							true
+						);
 					else
 						$fhcAlert.alertError(error.message);
 				},
@@ -250,6 +267,23 @@ export default {
 						message += 'Line Number: ' + error.line + '\n';
 
 					$fhcAlert.alertSystemError(message);
+				},
+				auth(error, config) {
+					const $fhcAlert = app.config.globalProperties.$fhcAlert;
+
+					var message = '';
+					message += 'Controller name: ' + error.controller + '\n';
+					message += 'Method name: ' + error.method + '\n';
+					message += 'Required permissions: ' + error.required_permissions;
+					if (config?.errorHeader)
+						$fhcAlert.alertDefault(
+							'error',
+							Array.isArray(config.errorHeader) ? app.config.globalProperties.$p.t.apply(null, config.errorHeader) : config.errorHeader,
+							error.message,
+							true
+						);
+					else
+						$fhcAlert.alertDefault('error', error.message, message);
 				}
 			}
 		};
@@ -276,7 +310,9 @@ export default {
 			}
 		}
 
-		app.config.globalProperties.$fhcApi.factory = new FhcApiFactoryWrapper(FhcApiFactory);
+		const mergedFhcApiFactory = options?.factory ? {...FhcApiFactory, ...options.factory} : FhcApiFactory;
+
+		app.config.globalProperties.$fhcApi.factory = new FhcApiFactoryWrapper(mergedFhcApiFactory);
 
 	}
 };

public/js/plugin/Phrasen.js

@@ -1,3 +1,5 @@
+import FhcApi from './FhcApi.js';
+
 const categories = Vue.reactive({});
 const loadingModules = {};
 
@@ -21,20 +23,19 @@ function getValueForLoadedPhrase(category, phrase, params) {
 const phrasen = {
 	loadCategory(category) {
 		if (Array.isArray(category))
-			return Promise.all(category.map(cat => this.loadCategory(cat)));
+			return Promise.all(category.map(this.config.globalProperties
+				.$p.loadCategory));
 		if (!loadingModules[category])
-			loadingModules[category] = axios
+			loadingModules[category] = this.config.globalProperties
-				.get(FHC_JS_DATA_STORAGE_OBJECT.app_root + FHC_JS_DATA_STORAGE_OBJECT.ci_router + '/components/Phrasen/loadModule/' + category)
+				.$fhcApi.factory.phrasen.loadCategory(category)
+				.then(res => res?.data ? extractCategory(res.data, category) : {})
 				.then(res => {
-					if (res.data.retval)
+					categories[category] = res;
-						categories[category] = extractCategory(res.data.retval, category);
-					else
-						categories[category] = {};
 				});
 		return loadingModules[category];
 	},
 	t_ref(category, phrase, params) {
-		console.warn('depricated');
+		console.warn('deprecated');
 		return Vue.computed(() => this.t(category, phrase, params));
 	},
 	t(category, phrase, params) {
@@ -62,6 +63,11 @@ const phrasen = {
 
 export default {
 	install(app, options) {
-		app.config.globalProperties.$p = phrasen;
+		app.use(FhcApi, options?.fhcApi || undefined);
+		app.config.globalProperties.$p = {
+			t: phrasen.t,
+			loadCategory: cat => phrasen.loadCategory.call(app, cat),
+			t_ref: phrasen.t_ref
+		};
 	}
 }

rdf/AntragAbmeldung.xml.php

@@ -36,7 +36,7 @@ else
 
 
 $query = "
-	SELECT stg.bezeichnung, bezeichnung_mehrsprachig[(SELECT index FROM public.tbl_sprache WHERE sprache=" . $db->db_add_param(getSprache(), FHC_STRING) . ")], studierendenantrag_id, matrikelnr, studienjahr_kurzbz, a.studiensemester_kurzbz, vorname, nachname, studiengang_kz, pss.ausbildungssemester AS semester, a.grund
+	SELECT stg.bezeichnung, bezeichnung_mehrsprachig[(SELECT index FROM public.tbl_sprache WHERE sprache=" . $db->db_add_param(getSprache(), FHC_STRING) . ")], studierendenantrag_id, matrikelnr, studienjahr_kurzbz, a.studiensemester_kurzbz, vorname, nachname, studiengang_kz, pss.ausbildungssemester AS semester, pss.datum, a.grund
 	FROM
 	campus.tbl_studierendenantrag a
 	JOIN public.tbl_student USING (prestudent_id)
@@ -56,16 +56,18 @@ if (!$db->db_query($query) || !$db->db_num_rows())
 <?xml version='1.0' encoding='UTF-8' standalone='yes'?>
 <antraege>
 	<?php while($row = $db->db_fetch_object()) { ?>
-	<antrag>
+		<?php $abmeldedatum = new DateTime($row->datum); ?>
-        <name><![CDATA[<?= trim($row->vorname . ' ' . $row->nachname); ?>]]></name>
+		<antrag>
-        <studiengang><![CDATA[<?= $row->bezeichnung; ?>]]></studiengang>
+			<name><![CDATA[<?= trim($row->vorname . ' ' . $row->nachname); ?>]]></name>
-        <organisationsform><![CDATA[<?= $row->bezeichnung_mehrsprachig; ?>]]></organisationsform>
+			<studiengang><![CDATA[<?= $row->bezeichnung; ?>]]></studiengang>
-        <personenkz><![CDATA[<?= $row->matrikelnr; ?>]]></personenkz>
+			<organisationsform><![CDATA[<?= $row->bezeichnung_mehrsprachig; ?>]]></organisationsform>
-        <studienjahr><![CDATA[<?= $row->studienjahr_kurzbz; ?>]]></studienjahr>
+			<personenkz><![CDATA[<?= $row->matrikelnr; ?>]]></personenkz>
-        <studiensemester><![CDATA[<?= $row->studiensemester_kurzbz; ?>]]></studiensemester>
+			<studienjahr><![CDATA[<?= $row->studienjahr_kurzbz; ?>]]></studienjahr>
-        <semester><![CDATA[<?= $row->semester; ?>]]></semester>
+			<studiensemester><![CDATA[<?= $row->studiensemester_kurzbz; ?>]]></studiensemester>
-        <grund><![CDATA[<?= $row->grund; ?>]]></grund>
+			<semester><![CDATA[<?= $row->semester; ?>]]></semester>
-	</antrag>
+			<abmeldedatum><![CDATA[<?= $abmeldedatum->format('d.m.Y'); ?>]]></abmeldedatum>
+			<grund><![CDATA[<?= $row->grund; ?>]]></grund>
+		</antrag>
 	<?php } ?>
 </antraege>
 

rdf/AntragAbmeldungStgl.xml.php

@@ -36,7 +36,7 @@ else
 
 
 $query = "
-	SELECT stg.bezeichnung, bezeichnung_mehrsprachig[(SELECT index FROM public.tbl_sprache WHERE sprache=" . $db->db_add_param(getSprache(), FHC_STRING) . ")], studierendenantrag_id, matrikelnr, studienjahr_kurzbz, a.studiensemester_kurzbz, vorname, nachname, studiengang_kz, pss.ausbildungssemester AS semester, a.grund
+	SELECT stg.bezeichnung, bezeichnung_mehrsprachig[(SELECT index FROM public.tbl_sprache WHERE sprache=" . $db->db_add_param(getSprache(), FHC_STRING) . ")], studierendenantrag_id, matrikelnr, studienjahr_kurzbz, a.studiensemester_kurzbz, vorname, nachname, studiengang_kz, pss.ausbildungssemester AS semester, pss.bestaetigtam, a.grund
 	FROM
 	campus.tbl_studierendenantrag a
 	JOIN public.tbl_student USING (prestudent_id)
@@ -56,15 +56,17 @@ if (!$db->db_query($query) || !$db->db_num_rows())
 <?xml version='1.0' encoding='UTF-8' standalone='yes'?>
 <antraege>
 	<?php while($row = $db->db_fetch_object()) { ?>
-        <antrag>
+		<?php $abmeldedatum = new DateTime($row->bestaetigtam); ?>
-            <name><![CDATA[<?= trim($row->vorname . ' ' . $row->nachname); ?>]]></name>
+		<antrag>
-            <studiengang><![CDATA[<?= $row->bezeichnung; ?>]]></studiengang>
+			<name><![CDATA[<?= trim($row->vorname . ' ' . $row->nachname); ?>]]></name>
-            <organisationsform><![CDATA[<?= $row->bezeichnung_mehrsprachig; ?>]]></organisationsform>
+			<studiengang><![CDATA[<?= $row->bezeichnung; ?>]]></studiengang>
-            <personenkz><![CDATA[<?= $row->matrikelnr; ?>]]></personenkz>
+			<organisationsform><![CDATA[<?= $row->bezeichnung_mehrsprachig; ?>]]></organisationsform>
-            <studienjahr><![CDATA[<?= $row->studienjahr_kurzbz; ?>]]></studienjahr>
+			<personenkz><![CDATA[<?= $row->matrikelnr; ?>]]></personenkz>
-            <studiensemester><![CDATA[<?= $row->studiensemester_kurzbz; ?>]]></studiensemester>
+			<studienjahr><![CDATA[<?= $row->studienjahr_kurzbz; ?>]]></studienjahr>
-            <semester><![CDATA[<?= $row->semester; ?>]]></semester>
+			<studiensemester><![CDATA[<?= $row->studiensemester_kurzbz; ?>]]></studiensemester>
-            <grund><![CDATA[<?= $row->grund; ?>]]></grund>
+			<semester><![CDATA[<?= $row->semester; ?>]]></semester>
+			<abmeldedatum><![CDATA[<?= $abmeldedatum->format('d.m.Y'); ?>]]></abmeldedatum>
+			<grund><![CDATA[<?= $row->grund; ?>]]></grund>
 	</antrag>
 	<?php } ?>
 </antraege>

rdf/AntragWiederholung.xml.php

@@ -5,6 +5,42 @@ require_once('../config/vilesci.config.inc.php');
 require_once('../include/functions.inc.php');
 require_once('../include/basis_db.class.php');
 
+// Get CodeIgniter Config
+// Get Environment Var
+if (defined('CI_ENVIRONMENT')) $_SERVER['CI_ENV'] = CI_ENVIRONMENT;
+define('ENVIRONMENT', isset($_SERVER['CI_ENV']) ? $_SERVER['CI_ENV'] : 'development');
+
+// Get BASEPATH Var
+$system_path = dirname(__FILE__).'/../vendor/codeigniter/framework/system';
+if (($_temp = realpath($system_path)) !== FALSE)
+	$system_path = $_temp.'/';
+else
+	$system_path = rtrim($system_path, '/').'/';
+define('BASEPATH', str_replace('\\', '/', $system_path));
+
+// Get APPPATH Var
+$application_folder = dirname(__FILE__).'/../application';
+if (is_dir($application_folder)) {
+	if (($_temp = realpath($application_folder)) !== FALSE)
+		$application_folder = $_temp;
+	define('APPPATH', $application_folder.DIRECTORY_SEPARATOR);
+} else {
+	if (!is_dir(BASEPATH.$application_folder.DIRECTORY_SEPARATOR)) {
+		header('HTTP/1.1 503 Service Unavailable.', TRUE, 503);
+		echo 'Your application folder path does not appear to be set correctly. Please open the following file and correct this: '.SELF;
+		exit(3); // EXIT_CONFIG
+	}
+	define('APPPATH', BASEPATH.$application_folder.DIRECTORY_SEPARATOR);
+}
+
+// Load studierendenantrag Config
+foreach (['studierendenantrag', ENVIRONMENT.DIRECTORY_SEPARATOR.'studierendenantrag'] as $location) {
+	$file_path = APPPATH . 'config/' . $location . '.php';
+	if (file_exists($file_path))
+		include($file_path);
+}
+// Get CodeIgniter Config end
+
 $db = new basis_db();
 
 if (isset($_REQUEST["xmlformat"]) && $_REQUEST["xmlformat"] == "xml")
@@ -34,9 +70,24 @@ if (isset($_REQUEST["xmlformat"]) && $_REQUEST["xmlformat"] == "xml")
 else
 	die('<error>Format not supported</error>');
 
+$blacklist = '';
+if ($config['note_blacklist_wiederholung']) {
+	$blacklist = " AND n.note NOT IN (" . $db->db_implode4SQL($config['note_blacklist_wiederholung']) . ")";
+}
+
 
 $query = "
-	SELECT stg.bezeichnung, bezeichnung_mehrsprachig[(SELECT index FROM public.tbl_sprache WHERE sprache=" . $db->db_add_param(getSprache(), FHC_STRING) . ")], studierendenantrag_id, matrikelnr, studienjahr_kurzbz, a.studiensemester_kurzbz, vorname, nachname, studiengang_kz, pss.ausbildungssemester AS semester, (SELECT pt.text FROM system.tbl_phrase p JOIN system.tbl_phrasentext pt USING(phrase_id) WHERE p.category=" . $db->db_add_param('studierendenantrag', FHC_STRING) . " AND p.phrase=" . $db->db_add_param('grund_Wiederholung_deadline', FHC_STRING) . " AND pt.sprache=" . $db->db_add_param(getSprache(), FHC_STRING) . " LIMIT 1) AS grund
+	SELECT stg.bezeichnung, tbl_orgform.bezeichnung_mehrsprachig[(SELECT index FROM public.tbl_sprache WHERE sprache=" . $db->db_add_param(getSprache(), FHC_STRING) . ")], studierendenantrag_id, matrikelnr, studienjahr_kurzbz, a.studiensemester_kurzbz, vorname, nachname, studiengang_kz, pss.ausbildungssemester AS semester, (
+			SELECT
+				insertamum::date
+			FROM
+				campus.tbl_studierendenantrag_status
+			WHERE
+				studierendenantrag_id = a.studierendenantrag_id AND studierendenantrag_statustyp_kurzbz = 'Abgemeldet'
+			ORDER BY
+				insertamum DESC
+			LIMIT 1
+		) AS abmeldedatum, (SELECT pt.text FROM system.tbl_phrase p JOIN system.tbl_phrasentext pt USING(phrase_id) WHERE p.category=" . $db->db_add_param('studierendenantrag', FHC_STRING) . " AND p.phrase=" . $db->db_add_param('grund_Wiederholung_deadline', FHC_STRING) . " AND pt.sprache=" . $db->db_add_param(getSprache(), FHC_STRING) . " LIMIT 1) AS grund
 	FROM
 	campus.tbl_studierendenantrag a
 	JOIN public.tbl_student USING (prestudent_id)
@@ -56,15 +107,19 @@ if (!$db->db_query($query) || !$db->db_num_rows())
 <?xml version='1.0' encoding='UTF-8' standalone='yes'?>
 <antraege>
 	<?php while($row = $db->db_fetch_object()) { ?>
-        <antrag>
+		<?php
-            <name><![CDATA[<?= trim($row->vorname . ' ' . $row->nachname); ?>]]></name>
+			$abmeldedatum = new DateTime($row->abmeldedatum);
-            <studiengang><![CDATA[<?= $row->bezeichnung; ?>]]></studiengang>
+		?>
-            <organisationsform><![CDATA[<?= $row->bezeichnung_mehrsprachig; ?>]]></organisationsform>
+		<antrag>
-            <personenkz><![CDATA[<?= $row->matrikelnr; ?>]]></personenkz>
+			<name><![CDATA[<?= trim($row->vorname . ' ' . $row->nachname); ?>]]></name>
-            <studienjahr><![CDATA[<?= $row->studienjahr_kurzbz; ?>]]></studienjahr>
+			<studiengang><![CDATA[<?= $row->bezeichnung; ?>]]></studiengang>
-            <studiensemester><![CDATA[<?= $row->studiensemester_kurzbz; ?>]]></studiensemester>
+			<organisationsform><![CDATA[<?= $row->bezeichnung_mehrsprachig; ?>]]></organisationsform>
-            <semester><![CDATA[<?= $row->semester; ?>]]></semester>
+			<personenkz><![CDATA[<?= $row->matrikelnr; ?>]]></personenkz>
-            <grund><![CDATA[<?= $row->grund; ?>]]></grund>
+			<studienjahr><![CDATA[<?= $row->studienjahr_kurzbz; ?>]]></studienjahr>
+			<studiensemester><![CDATA[<?= $row->studiensemester_kurzbz; ?>]]></studiensemester>
+			<semester><![CDATA[<?= $row->semester; ?>]]></semester>
+			<abmeldedatum><![CDATA[<?= $abmeldedatum->format('d.m.Y'); ?>]]></abmeldedatum>
+			<grund><![CDATA[<?= $row->grund; ?>]]></grund>
 	</antrag>
 	<?php } ?>
 </antraege>

rdf/abschlusspruefung.rdf.php

@@ -343,7 +343,7 @@ if ($xmlformat=='rdf')
 	$rdf_url='http://www.technikum-wien.at/abschlusspruefung';
 	function draw_content($row)
 	{
-		global $rdf_url, $datum_obj;
+		global $rdf_url, $datum_obj, $abschlussbeurteilung_arr;
 		$vorsitz = '';
 		$pruefer1= '';
 		$pruefer2= '';
@@ -380,6 +380,7 @@ if ($xmlformat=='rdf')
 				<ABSCHLUSSPRUEFUNG:pruefer3><![CDATA['.$row->pruefer3.']]></ABSCHLUSSPRUEFUNG:pruefer3>
 				<ABSCHLUSSPRUEFUNG:pruefer3_nachname><![CDATA['.$pruefer3.']]></ABSCHLUSSPRUEFUNG:pruefer3_nachname>
 				<ABSCHLUSSPRUEFUNG:abschlussbeurteilung_kurzbz><![CDATA['.$row->abschlussbeurteilung_kurzbz.']]></ABSCHLUSSPRUEFUNG:abschlussbeurteilung_kurzbz>
+				<ABSCHLUSSPRUEFUNG:abschlussbeurteilung_bezeichnung><![CDATA['.($row->abschlussbeurteilung_kurzbz!=''?$abschlussbeurteilung_arr[$row->abschlussbeurteilung_kurzbz]:'').']]></ABSCHLUSSPRUEFUNG:abschlussbeurteilung_bezeichnung>
 				<ABSCHLUSSPRUEFUNG:notekommpruef><![CDATA['.$row->note.']]></ABSCHLUSSPRUEFUNG:notekommpruef>
 				<ABSCHLUSSPRUEFUNG:akadgrad_id><![CDATA['.$row->akadgrad_id.']]></ABSCHLUSSPRUEFUNG:akadgrad_id>
 				<ABSCHLUSSPRUEFUNG:datum><![CDATA['.$datum_obj->convertISODate($row->datum).']]></ABSCHLUSSPRUEFUNG:datum>

rdf/diplomasupplement.xml.php

@@ -34,19 +34,22 @@ require_once('../include/studiensemester.class.php');
 require_once('../include/student.class.php');
 require_once('../include/firma.class.php');
 require_once('../include/note.class.php');
+require_once('../include/studienplan.class.php');
+require_once('../include/lehrveranstaltung.class.php');
+require_once('../include/lehrform.class.php');
+require_once('../include/sprache.class.php');
 
 $datum = new datum();
 $db = new basis_db();
 
 if (isset($_REQUEST["xmlformat"]) && $_REQUEST["xmlformat"] == "xml")
 {
-
 	if(isset($_GET['uid']))
 		$uid = $_GET['uid'];
 	else
 		$uid = null;
 
-	$uid_arr = explode(";",$uid);
+	$uid_arr = explode(";", $uid);
 
 	echo "<?xml version='1.0' encoding='UTF-8' standalone='yes'?> ";
 	echo "<supplements>";
@@ -60,9 +63,11 @@ if (isset($_REQUEST["xmlformat"]) && $_REQUEST["xmlformat"] == "xml")
 						vw_student.matrikelnr, vw_student.prestudent_id,
 						tbl_studiengang.bezeichnung, tbl_studiengang.english, tbl_studiengang.studiengang_kz,
 						tbl_studiengang.typ, tbl_studiengang.mischform, tbl_studiengang.max_semester,
-						tbl_studiengang.orgform_kurzbz
+						tbl_studiengang.orgform_kurzbz, tbl_person.matr_nr
 				  FROM
 						campus.vw_student JOIN public.tbl_studiengang USING(studiengang_kz)
+				  JOIN
+				   		public.tbl_person USING (person_id)
 				  WHERE
 						uid = ".$db->db_add_param($uid_arr[$i]);
 
@@ -96,7 +101,12 @@ if (isset($_REQUEST["xmlformat"]) && $_REQUEST["xmlformat"] == "xml")
 		echo '		<vornamen><![CDATA['.$row->vornamen.']]></vornamen>';
 		echo '		<name><![CDATA['.$row->vorname.' '.$row->nachname.']]></name>';
 		echo '		<geburtsdatum><![CDATA['.$datum->convertISODate($row->gebdatum).']]></geburtsdatum>';
+
+		//Print in Transcript of Record
 		echo '		<matrikelnummer>'.TRIM($row->matrikelnr).'</matrikelnummer>';
+
+		//Angaben zur Person /Information identifying the holder of the qualification
+		echo '		<matr_nr><![CDATA['.$row->matr_nr.']]></matr_nr>';
 		echo '		<studiengang_kz>'.$studiengang_kz.'</studiengang_kz>';
 
 		$prestudent = new prestudent($row->prestudent_id);
@@ -108,6 +118,7 @@ if (isset($_REQUEST["xmlformat"]) && $_REQUEST["xmlformat"] == "xml")
 			{
 				$studiengangbezeichnung = $studienordnung->__get('studiengangbezeichnung');
 				$studiengangbezeichnung_englisch = $studienordnung->__get('studiengangbezeichnung_englisch');
+				$studienordnung_id =$studienordnung->__get('studienordnung_id');
 			}
 		}
 		$studiengang_bezeichnung = empty($studiengangbezeichnung) ? $row->bezeichnung : $studiengangbezeichnung;
@@ -115,6 +126,7 @@ if (isset($_REQUEST["xmlformat"]) && $_REQUEST["xmlformat"] == "xml")
 
 		echo '		<studiengang_bezeichnung_deutsch><![CDATA['.$studiengang_bezeichnung.']]></studiengang_bezeichnung_deutsch>';
 		echo '		<studiengang_bezeichnung_englisch><![CDATA['.$studiengang_bezeichnung_englisch.']]></studiengang_bezeichnung_englisch>';
+		echo '<studienordnung_id>'.$studienordnung_id.'</studienordnung_id>';
 
 		$prestudent = new prestudent();
 		$prestudent->getFirstStatus($row->prestudent_id, 'Student');
@@ -126,8 +138,12 @@ if (isset($_REQUEST["xmlformat"]) && $_REQUEST["xmlformat"] == "xml")
 		{
 			$angerechneteECTS=($semesterNumberStart-1)*30; // 30 ECTS pro Semester
 			echo '		<angerechnete_ects_quereinstieg>'.$angerechneteECTS.'</angerechnete_ects_quereinstieg>';
+
+            $end_semester_anrechnung = $semesterNumberStart - 1;
+            echo '      <start_semester_anrechnung_number>1</start_semester_anrechnung_number>';
+            echo '      <end_semester_anrechnung_number>'. $end_semester_anrechnung .'</end_semester_anrechnung_number>';
 		}
-		echo '      <start_semester>'.substr($prestudent->studiensemester_kurzbz,2,6).'</start_semester>';
+		echo '      <start_semester>'.substr($prestudent->studiensemester_kurzbz, 2, 6).'</start_semester>';
 		echo '      <start_semester_number>'.$prestudent->ausbildungssemester.'</start_semester_number>';
 		$prestudent->getLastStatus($row->prestudent_id, null);
 		$semesterNumberEnd = $prestudent->ausbildungssemester;
@@ -254,6 +270,25 @@ if (isset($_REQUEST["xmlformat"]) && $_REQUEST["xmlformat"] == "xml")
 				break;
 		}
 
+		//Anforderungen durch Lernergebnisse des Studiums ersetzen
+		$addon_obj = new addon();
+		$addonStgAktiv = $addon_obj->checkActiveAddon("studiengangsverwaltung");
+
+		if($addonStgAktiv)
+		{
+
+			require_once('../addons/studiengangsverwaltung/include/qualifikationsziel.class.php');
+			$qualifikationsziel = new qualifikationsziel();
+			$qualifikationsziel->getAll($studienordnung_id);
+			if (isset($qualifikationsziel->result[0]))
+			{
+				$qualifikation_beschreibung = $qualifikationsziel->result[0]->data[1]->elements[0];
+				$qualifikation_beschreibung = json2odt($qualifikation_beschreibung);
+				echo "<lernergebnisse><![CDATA[$qualifikation_beschreibung]]></lernergebnisse>";
+			}
+
+		}
+
 		if($row->typ=='d')
 		{
 			echo '		<niveau_code>UNESCO ISCED 7</niveau_code>';
@@ -275,8 +310,8 @@ if (isset($_REQUEST["xmlformat"]) && $_REQUEST["xmlformat"] == "xml")
 			echo '		<anforderungen_englisch><![CDATA[The program requires the positive completion of all courses (lectures, labs, seminars, project work, and integrated courses) to the extend of 30 ECTS per semester according to the curriculum.  The program integrates technical, economical, management and personal study elements. The degree is awarded upon the successful completion of a Master´s Thesis and the final examination. The program (classification number '.$studiengang_kz.') is accredited by AQ Austria.]]></anforderungen_englisch>';
 			echo '		<zugangsberechtigung_deutsch><![CDATA[Der Abschluss des Masterstudiengangs berechtigt zu einem facheinschlägigen Doktoratsstudium an einer Universität (mit eventuellen Zusatzprüfungen).]]></zugangsberechtigung_deutsch>';
 			echo '		<zugangsberechtigung_englisch><![CDATA[The successful completion of the Master Degree Program qualifies the graduate to apply for admission to a relevant Doctoral Degree Program at a University (additional qualifying exams may be required).    ]]></zugangsberechtigung_englisch>';
-			echo '		<niveau_deutsch>Masterstudium (UNESCO ISCED 7)</niveau_deutsch>';
+			echo '		<niveau_deutsch>Masterstudium: UNESCO ISCED 7; Zuordnung nationaler Qualifikationsrahmen 7</niveau_deutsch>';
-			echo '		<niveau_englisch>Master degree program (UNESCO ISCED 7)</niveau_englisch>';
+			echo '		<niveau_englisch>Master degree program: UNESCO ISCED 7; Classification national qualification framework 7</niveau_englisch>';
 		}
 		elseif($row->typ=='b')
 		{
@@ -287,8 +322,8 @@ if (isset($_REQUEST["xmlformat"]) && $_REQUEST["xmlformat"] == "xml")
 			echo '		<anforderungen_englisch><![CDATA[The program requires the positive completion of all courses (lectures, labs, seminars, project work, and integrated courses) to the extend of 30 ECTS per semester according to the curriculum. The program integrates technical, economical, management and personal study elements. '.$anforderungen_praxiseng.' The degree is awarded upon the successful completion of 1 bachelor theses and the final examination. The program (classification number '.$studiengang_kz.') is accredited by AQ Austria.]]></anforderungen_englisch>';
 			echo '		<zugangsberechtigung_deutsch><![CDATA[Der Abschluss des Bachelorstudiengangs berechtigt zu einem facheinschlägigen Magister- bzw. Master-Studium an einer fachhochschulischen Einrichtung oder Universität (mit eventuellen Zusatzprüfungen).]]></zugangsberechtigung_deutsch>';
 			echo '		<zugangsberechtigung_englisch><![CDATA[The successful completion of the Bachelor Degree Program qualifies the graduate to apply for admission to a relevant Master Degree Program at a University of Applied Sciences or a University (additional qualifying exams may be required).]]></zugangsberechtigung_englisch>';
-			echo '		<niveau_deutsch>Bachelorstudium (UNESCO ISCED 6)</niveau_deutsch>';
+			echo '		<niveau_deutsch>Bachelorstudium: UNESCO ISCED 6;  Zuordnung nationaler Qualifikationsrahmen 6</niveau_deutsch>';
-			echo '		<niveau_englisch>Bachelor degree program (UNESCO ISCED 6)</niveau_englisch>';
+			echo '		<niveau_englisch>Bachelor degree program: UNESCO ISCED 6; Classification national qualification framework 6</niveau_englisch>';
 		}
 		elseif($row->typ=='r')
 		{
@@ -329,6 +364,9 @@ if (isset($_REQUEST["xmlformat"]) && $_REQUEST["xmlformat"] == "xml")
 			echo "		<beurteilung_english>Not applicable within this curriculum.</beurteilung_english>";
 		}
 
+		echo "		<zugangsber_reglementierte_berufe>Zugang zu reglementierten Berufen nach Maßgabe der berufsrechtlichen Vorschriften;	Diplom im Sinne des Art.11 lit.c/d/e der Richtlinie 2005/36/EG über die Anerkennung von Berufsqualifikationen</zugangsber_reglementierte_berufe>";
+		echo "		<zugangsber_reglementierte_berufe_englisch>Access to regulated professions according to professional regulations; diploma in the sense of Art.11 lit.(c)/(d)/(e) of directive 2005/36/EG</zugangsber_reglementierte_berufe_englisch>";
+
 		$qry = "SELECT * FROM lehre.tbl_akadgrad WHERE akadgrad_id=".$db->db_add_param($akadgrad_id);
 		$titel_de = '';
 		$titel_en = '';
@@ -411,7 +449,7 @@ if (isset($_REQUEST["xmlformat"]) && $_REQUEST["xmlformat"] == "xml")
 		$abschlussbeurteilung='';
 		// Hole Datum der Sponsion -> wenn keine vorhanden nimm aktuelles datum
 		$qry = "SELECT
-					sponsion, tbl_abschlussbeurteilung.bezeichnung_english, datum, pruefungstyp_kurzbz
+					sponsion, tbl_abschlussbeurteilung.bezeichnung_english, datum, pruefungstyp_kurzbz, bezeichnung
 				FROM
 					lehre.tbl_abschlusspruefung
 					JOIN lehre.tbl_abschlussbeurteilung USING(abschlussbeurteilung_kurzbz)
@@ -431,11 +469,13 @@ if (isset($_REQUEST["xmlformat"]) && $_REQUEST["xmlformat"] == "xml")
 				$sponsion_datum = $datum->formatDatum($row1->sponsion, 'd.m.Y');
 				$abschlusspruefungsdatum = $datum->formatDatum($row1->datum, 'd.m.Y');
 				$abschlussbeurteilung = $row1->bezeichnung_english;
+				$abschlussbeurteilung_deutsch = $row1->bezeichnung;
 				$pruefungstyp_kurzbz = $row1->pruefungstyp_kurzbz;
 			}
 		}
 		echo "		<pruefungstyp_kurzbz>$pruefungstyp_kurzbz</pruefungstyp_kurzbz>";
 		echo "		<abschlussbeurteilung>$abschlussbeurteilung</abschlussbeurteilung>";
+		echo "		<abschlussbeurteilung_deutsch>$abschlussbeurteilung_deutsch</abschlussbeurteilung_deutsch>";
 		echo "		<abschlusspruefungsdatum>$abschlusspruefungsdatum</abschlusspruefungsdatum>";
 		echo "      <sponsion_datum>$sponsion_datum</sponsion_datum>";
 
@@ -578,6 +618,41 @@ if (isset($_REQUEST["xmlformat"]) && $_REQUEST["xmlformat"] == "xml")
 		$ects_total = 0;
 		$ects_total_positiv = 0;
 
+		//Anrechnung Quereinsteiger
+		echo ' <anrechnungen>';
+
+    	//Version Studienordnung
+		if($semesterNumberStart>1)
+		{
+			$maxSemester = $semesterNumberStart;
+			$summe_ects_orgform = 0;
+			$summe_sws_orgform = 0;
+			for($j = 1; $j <$maxSemester; $j++)
+			{
+				$summe_ects_semester = 0;
+				$summe_sws_semester = 0;
+				echo '	<stosemester>';
+				echo '	<stosemester_nr><![CDATA['.$j.']]></stosemester_nr>';
+
+				$lv = new lehrveranstaltung();
+				$lv->loadLehrveranstaltungStudienplan($studienplan_id, $j);
+				$tree = $lv->getLehrveranstaltungTree();
+
+				printLehrveranstaltungTree($tree);
+
+				//if ($lv->lehrtyp_kurzbz!='modul')
+				//	$summe += $lv->ects;
+
+				echo '	<lv_summe_ects_semester><![CDATA['.$summe_ects_semester.']]></lv_summe_ects_semester>';
+				echo '	<lv_summe_sws_semester><![CDATA['.round($summe_sws_semester, 2).']]></lv_summe_sws_semester>';
+
+				$summe_ects_orgform += $summe_ects_semester;
+				$summe_sws_orgform += $summe_sws_semester;
+				echo '</stosemester>';
+			}
+		}
+		echo ' </anrechnungen>';
+
 		echo "<studiensemester>";
 		for($start = $semesterNumberStart; $start <= $semesterNumberEnd; $start++)
 		{
@@ -615,16 +690,16 @@ if (isset($_REQUEST["xmlformat"]) && $_REQUEST["xmlformat"] == "xml")
 			// Array der Semester
 			$aktuellesSemester = $semester_kurzbz;
 
-			$semester = mb_substr($semester_kurzbz[0],0,2);
+			$semester = mb_substr($semester_kurzbz[0], 0, 2);
-			$year = mb_substr($semester_kurzbz[0], 2,4);
+			$year = mb_substr($semester_kurzbz[0], 2, 4);
 
 			if($semester == 'SS')
 				$semester_kurzbz = 'Summer Semester '.$year;
-			else if($semester == 'WS')
+			elseif($semester == 'WS')
 			{
-				$helpyear = mb_substr($year, 2,2);
+				$helpyear = mb_substr($year, 2, 2);
 				$helpyear +=1;
-				$helpyear = sprintf("%02d",$helpyear);
+				$helpyear = sprintf("%02d", $helpyear);
 				$semester_kurzbz = 'Winter Semester '.$year.'/'.$helpyear;
 			}
 
@@ -763,11 +838,12 @@ if (isset($_REQUEST["xmlformat"]) && $_REQUEST["xmlformat"] == "xml")
 					if($result_lehrform = $db->db_query($qry_lehrform))
 					{
 						while($row_lehrform = $db->db_fetch_object($result_lehrform))
-						{	if($y != 0)
+						{
-							$lehrform_kurzbz = $lehrform_kurzbz.', '.$row_lehrform->lehrform_kurzbz;
+							if($y != 0)
-						else
+								$lehrform_kurzbz = $lehrform_kurzbz.', '.$row_lehrform->lehrform_kurzbz;
-							$lehrform_kurzbz = $row_lehrform->lehrform_kurzbz;
+							else
-							$y++;
+								$lehrform_kurzbz = $row_lehrform->lehrform_kurzbz;
+								$y++;
 						}
 					}
 					$arrayLvAusbildungssemester[$row_stud->lehrveranstaltung_id]['lehrform_kurzbz']= $lehrform_kurzbz;
@@ -791,7 +867,7 @@ if (isset($_REQUEST["xmlformat"]) && $_REQUEST["xmlformat"] == "xml")
 					}
 
 					$datum = new datum();
-					$benotungsdatum = $datum->formatDatum($benotungsdatum,'d/m/Y');
+					$benotungsdatum = $datum->formatDatum($benotungsdatum, 'd/m/Y');
 					$arrayLvAusbildungssemester[$row_stud->lehrveranstaltung_id]['benotungsdatum']= $benotungsdatum;
 
 					$bezeichnung_englisch = $row_stud->bezeichnung_english;
@@ -1052,4 +1128,108 @@ function checkNote($note_alt, $note_neu)
 		return false;
 }
 
+//Funktionen für Andruck Studienordnung
+function cmp($a, $b)
+{
+	return strcmp($a->bezeichnung, $b->bezeichnung);
+}
+
+//newline \n durch string '\n' ersetzen (für Qualifikationsziele)
+function json2odt($str)
+{
+	$str = str_replace(array("\r\n", "\r", "\n"), '\n', $str);
+
+	return $str;
+}
+
+function printLehrveranstaltungTree($tree)
+{
+	global $summe_ects_semester, $summe_sws_semester;
+	usort($tree, "cmp");
+	foreach($tree as $lv)
+	{
+		if ($lv->export)
+		{
+			$db = new basis_db();
+			$lv_alvs = new lehrveranstaltung();
+			if(!$alvs = $lv_alvs->getALVS($lv->lehrveranstaltung_id, $lv->semester))
+				$alvs = '';
+			//Semesterwochen zum berechnen der SWS ermitteln
+			$qry = '	SELECT
+							wochen
+						FROM
+							public.tbl_semesterwochen
+						WHERE
+							studiengang_kz='.$lv->studiengang_kz.'
+						AND
+							semester='.$lv->semester;
+			if($wochen_stg = $db->db_query($qry))
+			{
+				if($db->db_num_rows($wochen_stg)==1)
+				{
+					$row_wochen = $db->db_fetch_object($wochen_stg);
+					$wochen = $row_wochen->wochen;
+				}
+				else
+					$wochen = '15';
+			}
+			if ($lv->semesterstunden!='')
+				$sws = ($lv->semesterstunden / $wochen);
+			else
+				$sws = 0;
+
+			//Bezeichnung der Lehrform
+			$lehrform_kurzbz = new lehrform();
+			$lehrform_kurzbz->load($lv->lehrform_kurzbz);
+
+			//Klasse "sprache" instanzieren, um anschließend die Sprache(e.g. "German") in der richtigen Sprache zu bekommen("Deutsch")
+			$sp = new sprache();
+
+
+			echo '  		<lehrveranstaltung>';
+			echo '              <lv_semester><![CDATA['.$lv->semester.']]></lv_semester>';
+			echo '              <lv_lehrtyp_kurzbz><![CDATA['.$lv->lehrtyp_kurzbz.']]></lv_lehrtyp_kurzbz>';
+			echo '              <lv_bezeichnung><![CDATA['.$lv->bezeichnung.']]></lv_bezeichnung>';
+			echo '              <lv_bezeichnung_en><![CDATA['.$lv->bezeichnung_english.']]></lv_bezeichnung_en>';
+			echo '              <lv_kurzbz><![CDATA['.$lv->kurzbz.']]></lv_kurzbz>';
+			echo '              <lv_lehrform_kurzbz><![CDATA['.$lv->lehrform_kurzbz.']]></lv_lehrform_kurzbz>';
+			echo '              <lv_lehrform_langbz><![CDATA['.$lehrform_kurzbz->bezeichnung.']]></lv_lehrform_langbz>';
+			echo '              <lv_gruppen><![CDATA[]]></lv_gruppen>';
+			echo '              <lv_ects><![CDATA['.$lv->ects.']]></lv_ects>';
+			echo '              <lv_semesterstunden><![CDATA['.$lv->semesterstunden.']]></lv_semesterstunden>';
+			echo '              <lv_sws><![CDATA['.$lv->sws.']]></lv_sws>';
+			echo '              <lv_lvs><![CDATA['.$lv->lvs.']]></lv_lvs>';
+			echo '              <lv_pflicht><![CDATA['.$lv->stpllv_pflicht.']]></lv_pflicht>';
+			echo '              <lv_studplan><![CDATA['.$lv->export.']]></lv_studplan>';
+			echo '              <lv_gen><![CDATA['.$lv->genehmigung.']]></lv_gen>';
+			echo '              <lv_anmerkung><![CDATA['.clearHtmlTags($lv->anmerkung).']]></lv_anmerkung>';
+			echo '				<lv_sprache><![CDATA['.$sp->getBezeichnung($lv->sprache, constant("DEFAULT_LANGUAGE")).']]></lv_sprache>';
+
+			//Wenn Modul verpflichtend und alle Childs frei wählbar, soll Modul für ects gezählt werden
+			$allChildsFree = true;
+			foreach ($lv->childs as $child)
+			{
+				if($child->stpllv_pflicht)
+				{
+					$allChildsFree = false;
+				}
+			}
+
+			if(($lv->lehrtyp_kurzbz!='modul' && $lv->stpllv_pflicht) || ($allChildsFree && $lv->lehrtyp_kurzbz=='modul' && $lv->stpllv_pflicht))
+			{
+				$summe_ects_semester += $lv->ects;
+				$summe_sws_semester += $sws;
+			}
+
+			// Darunterliegende LVs/Module
+			if(isset($lv->childs) && count($lv->childs)>0)
+			{
+				echo '<singlelehrveranstaltungen>';
+				printLehrveranstaltungTree($lv->childs, count($lv->childs));
+				echo '</singlelehrveranstaltungen>';
+			}
+			echo '</lehrveranstaltung>';
+		}
+	}
+}
 ?>

rdf/mitarbeiter.rdf.php

@@ -55,6 +55,11 @@ if (isset($_GET['stg_kz']))
 else
 	$stg_kz=null;
 
+if (isset($_GET['aktiv']))
+	$aktiv=$_GET['aktiv'];
+else
+	$aktiv=null;
+
 if (isset($_GET['fachbereich_id']))
 	$fachbereich_id=$_GET['fachbereich_id'];
 else
@@ -126,7 +131,7 @@ function draw_row($mitarbeiter)
 
 if($lehrveranstaltung_id==null && $filter==null && $mitarbeiter_uid==null)
 {
-	$ma=$mitarbeiter->getMitarbeiter($lektor,$fixangestellt,$stg_kz);
+	$ma=$mitarbeiter->getMitarbeiter($lektor,$fixangestellt,$stg_kz, $aktiv);
 
 	$stg_obj = new studiengang();
 	$stg_obj->getAll('typ, kurzbz', false);

system/dbupdate_3.4.php

@@ -48,12 +48,14 @@ require_once('dbupdate_3.4/30181_tabelle_anrechnung_neue_attribute_fuer_begruend
 require_once('dbupdate_3.4/29529_infocenter_anpassungen.php');
 require_once('dbupdate_3.4/29835_uhstat1_erfassung_der_uhstat1_daten_ueber_das_bewerbungstool.php');
 require_once('dbupdate_3.4/33714_erhoehter_studienbeitrag_fuer_drittsaatenangehoerig.php');
+require_once('dbupdate_3.4/37107_fristenmanagement.php');
 require_once('dbupdate_3.4/33003_bis_meldung_personal.php');
 require_once('dbupdate_3.4/36275_zeitaufzeichnung_karenz.php');
 require_once('dbupdate_3.4/21620_neues_feld_zum_erfassen_des_ESI.php');
 require_once('dbupdate_3.4/36530_bis_internationsalisierung_codextabelle_neuerungen.php');
 require_once('dbupdate_3.4/34543_ux_template.php');
 require_once('dbupdate_3.4/17513_Entwicklungsteam.php');
+require_once('dbupdate_3.4/28575_softwarebereitstellung.php');
 
 // *** Pruefung und hinzufuegen der neuen Attribute und Tabellen
 echo '<H2>Pruefe Tabellen und Attribute!</H2>';
@@ -171,7 +173,8 @@ $tabellen=array(
 	"hr.tbl_sachaufwandtyp" => array("sachaufwandtyp_kurzbz","bezeichnung","sort", "aktiv"),
 	"hr.tbl_stundensatz" => array("stundensatz_id","uid","stundensatztyp","stundensatz","oe_kurzbz","gueltig_von","gueltig_bis","insertamum","insertvon","updateamum","updatevon"),
 	"hr.tbl_stundensatztyp" => array("stundensatztyp","bezeichnung","aktiv","insertamum","insertvon","updateamum","updatevon"),
-	"hr.tbl_dienstverhaeltnis" => array("dienstverhaeltnis_id","mitarbeiter_uid","vertragsart_kurzbz","oe_kurzbz","von","bis","insertamum","insertvon","updateamum","updatevon"),
+	"hr.tbl_dienstverhaeltnis" => array("dienstverhaeltnis_id","mitarbeiter_uid","vertragsart_kurzbz","oe_kurzbz","von","bis","insertamum","insertvon","updateamum","updatevon","dvendegrund_kurzbz","dvendegrund_anmerkung"),
+	"hr.tbl_dvendegrund" => array("dvendegrund_kurzbz", "bezeichnung", "bezeichnung_mehrsprachig", "aktiv", "sort"),
 	"hr.tbl_vertragsart" => array("vertragsart_kurzbz","bezeichnung","anmerkung","dienstverhaeltnis","vertragsart_kurzbz_parent","aktiv","sort"),
 	"hr.tbl_vertragsbestandteil" => array("vertragsbestandteil_id","dienstverhaeltnis_id","vertragsbestandteiltyp_kurzbz","von", "bis","insertamum", "insertvon","updateamum","updatevon"),
 	"hr.tbl_vertragsbestandteiltyp" => array("vertragsbestandteiltyp_kurzbz","bezeichnung","ueberlappend"),
@@ -188,6 +191,9 @@ $tabellen=array(
 	"hr.tbl_gehaltsbestandteil" => array("gehaltsbestandteil_id","dienstverhaeltnis_id","vertragsbestandteil_id","gehaltstyp_kurzbz","von","bis","anmerkung","grundbetrag","betrag_valorisiert","valorisierungssperre","insertamum", "insertvon","updateamum","updatevon","valorisierung","auszahlungen"),
 	"hr.tbl_gehaltshistorie" => array("gehaltshistorie_id", "datum","betrag","gehaltsbestandteil_id","mitarbeiter_uid"),
 	"hr.tbl_gehaltstyp" => array("gehaltstyp_kurzbz","bezeichnung","valorisierung","sort","aktiv"),
+	"hr.tbl_frist" => array("frist_id","mitarbeiter_uid","ereignis_kurzbz","bezeichnung","datum","status_kurzbz","parameter","insertvon","insertamum","updatevon","updateamum"),
+	"hr.tbl_frist_ereignis" => array("ereignis_kurzbz","bezeichnung","manuell"),
+	"hr.tbl_frist_status" => array("status_kurzbz", "bezeichnung"),
 	"lehre.tbl_abschlussbeurteilung"  => array("abschlussbeurteilung_kurzbz","bezeichnung","bezeichnung_english","sort"),
 	"lehre.tbl_abschlusspruefung"  => array("abschlusspruefung_id","student_uid","vorsitz","pruefer1","pruefer2","pruefer3","abschlussbeurteilung_kurzbz","akadgrad_id","pruefungstyp_kurzbz","datum","uhrzeit","sponsion","anmerkung","updateamum","updatevon","insertamum","insertvon","ext_id","note","protokoll","endezeit","pruefungsantritt_kurzbz","freigabedatum"),
 	"lehre.tbl_abschlusspruefung_antritt"  => array("pruefungsantritt_kurzbz","bezeichnung","bezeichnung_english","sort"),

system/dbupdate_3.4/28260_vertraege.php

@@ -437,6 +437,136 @@ if ($result = $db->db_query("SELECT * FROM information_schema.tables WHERE table
 		if (! $db->db_query($qry))
 			echo '<strong>Vertraege: ' . $db->db_last_error() . '</strong><br>';
 		else
-			echo 'HR Schema und Vertagstabellen wurden neu erstellt';
+			echo 'HR Schema und Vertagstabellen wurden neu erstellt<br>';
+	}
+}
+
+if ($result = $db->db_query("SELECT * FROM information_schema.tables WHERE table_name='tbl_dvendegrund' AND table_schema='hr'"))
+{
+	if ($db->db_num_rows($result) == 0)
+	{
+		$qry = "
+		    CREATE TABLE hr.tbl_dvendegrund (
+			dvendegrund_kurzbz character varying(32) NOT NULL ,
+			bezeichnung character varying(255) NOT NULL,
+			bezeichnung_mehrsprachig character varying(255)[] NOT NULL,
+			aktiv boolean DEFAULT true NOT NULL,
+			sort integer DEFAULT 1 NOT NULL,
+			PRIMARY KEY (dvendegrund_kurzbz),
+			CONSTRAINT tbl_dvendegrund_bezeichnung_key UNIQUE (bezeichnung)
+		    );
+
+		    GRANT SELECT, UPDATE, INSERT, DELETE ON hr.tbl_dvendegrund TO vilesci;
+
+		    INSERT INTO 
+			hr.tbl_dvendegrund (dvendegrund_kurzbz, bezeichnung, bezeichnung_mehrsprachig) 
+		    VALUES
+			('kuendigung_arbeitnehmer', 'Kündigung durch Arbeitnehmer', ARRAY['Kündigung durch Arbeitnehmer', 'Cancellation by Employee']), 
+			('kuendigung_arbeitgeber', 'Kündigung durch Arbeitgeber', ARRAY['Kündigung durch Arbeitgeber', 'Cancellation by Employer']),
+			('entlassung', 'Entlassung', ARRAY['Entlassung', 'Dismissal']),
+			('sonstige', 'Sonstige', ARRAY['Sonstige', 'Miscellaneous']),
+			('einvernehmlich', 'Einvernehmliche Auflösung', ARRAY['Einvernehmliche Auflösung', 'Rescission']),
+			('ablaufzeit', 'Ablauf durch Zeit', ARRAY['Ablauf durch Zeit', 'Expired by lapse of time']);
+		";
+		if (! $db->db_query($qry))
+			echo '<strong>Vertraege: ' . $db->db_last_error() . '</strong><br>';
+		else
+			echo 'Tabelle tbl_dvendegrund wurde im HR Schema neu erstellt<br>';
+	}
+}
+
+if ($result = $db->db_query("SELECT * FROM information_schema.columns WHERE column_name='dvendegrund_kurzbz' AND table_name='tbl_dienstverhaeltnis' AND table_schema='hr'"))
+{
+	if ($db->db_num_rows($result) == 0)
+	{
+		$qry = "
+		    ALTER TABLE 
+			hr.tbl_dienstverhaeltnis 
+		    ADD COLUMN
+			dvendegrund_kurzbz character varying(255) 
+		    CONSTRAINT 
+			tbl_dvendegrund_fk 
+		    REFERENCES 
+			hr.tbl_dvendegrund(dvendegrund_kurzbz) 
+		    ON UPDATE 
+			cascade 
+		    ON DELETE 
+			restrict
+		";
+		if (! $db->db_query($qry))
+			echo '<strong>Vertraege: ' . $db->db_last_error() . '</strong><br>';
+		else
+			echo 'Spalte dvendegrund_kurzbz wurde in hr.tbl_dienstverhaeltnis neu erstellt<br>';
+	}
+}
+
+if ($result = $db->db_query("SELECT * FROM information_schema.columns WHERE column_name='dvendegrund_anmerkung' AND table_name='tbl_dienstverhaeltnis' AND table_schema='hr'"))
+{
+	if ($db->db_num_rows($result) == 0)
+	{
+		$qry = "
+		    ALTER TABLE 
+			hr.tbl_dienstverhaeltnis 
+		    ADD COLUMN
+			dvendegrund_anmerkung character varying(255)
+		";
+		if (! $db->db_query($qry))
+			echo '<strong>Vertraege: ' . $db->db_last_error() . '</strong><br>';
+		else
+			echo 'Spalte dvendegrund_anmerkung wurde in hr.tbl_dienstverhaeltnis neu erstellt<br>';
+	}
+}
+
+if ($result = $db->db_query("SELECT * FROM hr.tbl_vertragsart WHERE vertragsart_kurzbz='dvbund'"))
+{
+	if ($db->db_num_rows($result) == 0)
+	{
+		$qry = "
+		INSERT INTO hr.tbl_vertragsart
+		    (vertragsart_kurzbz, bezeichnung, anmerkung, dienstverhaeltnis, vertragsart_kurzbz_parent, aktiv, sort)
+		VALUES
+		    ('dvbund','DV zum Bund','Dienstverhältnis zum Bund', true, null, true, 400);
+		";
+
+		if (! $db->db_query($qry))
+			echo '<strong>Vertraege: ' . $db->db_last_error() . '</strong><br>';
+		else
+			echo 'Vertragsart "Dienstverhältnis zum Bund" erstellt.<br />';
+	}
+}
+
+if ($result = $db->db_query("SELECT * FROM hr.tbl_vertragsart WHERE vertragsart_kurzbz='dvanderengk'"))
+{
+	if ($db->db_num_rows($result) == 0)
+	{
+		$qry = "
+		INSERT INTO hr.tbl_vertragsart
+		    (vertragsart_kurzbz, bezeichnung, anmerkung, dienstverhaeltnis, vertragsart_kurzbz_parent, aktiv, sort)
+		VALUES
+		    ('dvanderengk','DV anderen Gebietskörperschaft','Dienstverhältnis zu einer anderen Gebietskörperschaft', true, null, true, 500);
+		";
+
+		if (! $db->db_query($qry))
+			echo '<strong>Vertraege: ' . $db->db_last_error() . '</strong><br>';
+		else
+			echo 'Vertragsart "Dienstverhältnis zu einer anderen Gebietskörperschaft" erstellt.<br />';
+	}
+}
+
+if ($result = $db->db_query("SELECT * FROM hr.tbl_vertragsart WHERE vertragsart_kurzbz='dvanderenbet'"))
+{
+	if ($db->db_num_rows($result) == 0)
+	{
+		$qry = "
+		INSERT INTO hr.tbl_vertragsart
+		    (vertragsart_kurzbz, bezeichnung, anmerkung, dienstverhaeltnis, vertragsart_kurzbz_parent, aktiv, sort)
+		VALUES
+		    ('dvanderenbet','DV anderen Bildungseinrichtung','Dienstverhältnis zu einer anderen Bildungseinrichtung oder einem anderen Träger', true, null, true, 600);
+		";
+
+		if (! $db->db_query($qry))
+			echo '<strong>Vertraege: ' . $db->db_last_error() . '</strong><br>';
+		else
+			echo 'Vertragsart "Dienstverhältnis zu einer anderen Bildungseinrichtung oder einem anderen Träger" erstellt.<br />';
 	}
 }