FHC-Core/application/controllers/components/Antrag/Leitung.php

<?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');
		$stgsNeuanlage = $this->permissionlib->getSTG_isEntitledFor('student/studierendenantrag');

		$stgs = [];

		if ($studiengaenge) {
			$result = $this->StudierendenantragModel->loadForStudiengaenge($studiengaenge);

			if (isError($result))
				return $this->outputJson($result);
			$antraege = getData($result) ?: [];

			foreach ($antraege as $antrag) {
				if (!isset($stgs[$antrag->studiengang_kz])) {
					$stgs[$antrag->studiengang_kz] = new stdClass();
					$stgs[$antrag->studiengang_kz]->bezeichnung = $antrag->bezeichnung;
					$stgs[$antrag->studiengang_kz]->orgform = $antrag->orgform;
					$stgs[$antrag->studiengang_kz]->studiengang_kz = $antrag->studiengang_kz;
				}
			}
		}

		if ($stgsNeuanlage) {
			$result = $this->StudierendenantragModel->loadForStudiengaenge($stgsNeuanlage);

			if (isError($result))
				return $this->outputJson($result);
			$antraege = getData($result) ?: [];

			foreach ($antraege as $antrag) {
				if (!isset($stgs[$antrag->studiengang_kz])) {
					$stgs[$antrag->studiengang_kz] = new stdClass();
					$stgs[$antrag->studiengang_kz]->bezeichnung = $antrag->bezeichnung;
					$stgs[$antrag->studiengang_kz]->orgform = $antrag->orgform;
					$stgs[$antrag->studiengang_kz]->studiengang_kz = $antrag->studiengang_kz;
				}
			}
		}

		$this->outputJsonSuccess($stgs);
	}

	public function getAntraege($studiengang = null)
	{

		if($studiengang)
			$studiengaenge = [$studiengang];
		else {
			$studiengaenge =$this->permissionlib->getSTG_isEntitledFor('student/antragfreigabe');
			if(!is_array($studiengaenge))
				$studiengaenge = [];


			$stgsNeuanlage = $this->permissionlib->getSTG_isEntitledFor('student/studierendenantrag');
			if(!is_array($stgsNeuanlage))
				$stgsNeuanlage = [];

			$studiengaenge = array_unique(array_merge($studiengaenge, $stgsNeuanlage));
		}


		$antraege = [];
		if ($studiengaenge) {
			$result = $this->StudierendenantragModel->loadForStudiengaenge($studiengaenge);
			if (isError($result)) {
				$this->output->set_status_header(500);
				return $this->outputJson('Internal Server Error');
			}
			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 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) ?: []);
	}
}