mirror of
https://github.com/FH-Complete/FHC-Core.git
synced 2026-06-01 20:29:29 +00:00
KarpAlex
1363 lines
44 KiB
PHP
1363 lines
44 KiB
PHP
<?php
|
|
|
|
if (! defined('BASEPATH')) exit('No direct script access allowed');
|
|
|
|
class PlausicheckLib
|
|
{
|
|
private $_ci; // Code igniter instance
|
|
private $_db; // database object
|
|
|
|
/**
|
|
* Object initialization
|
|
*/
|
|
public function __construct()
|
|
{
|
|
$this->_ci =& get_instance(); // get ci instance
|
|
|
|
// load models
|
|
$this->_ci->load->model('crm/Prestudent_model', 'PrestudentModel');
|
|
$this->_ci->load->model('crm/Prestudentstatus_model', 'PrestudentstatusModel');
|
|
$this->_ci->load->model('organisation/Studiensemester_model', 'StudiensemesterModel');
|
|
|
|
// get database for queries
|
|
$this->_db = new DB_Model();
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------------------------------
|
|
// Studiengang checks
|
|
|
|
/**
|
|
* Studiengang should be the same for prestudent and student.
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param prestudent_id int if check is to be executed only for one prestudent
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getStgPrestudentUngleichStgStudent($studiengang_kz = null, $prestudent_id = null)
|
|
{
|
|
$params = array();
|
|
|
|
$qry = "
|
|
SELECT
|
|
pre.person_id, pre.prestudent_id, stg.oe_kurzbz prestudent_stg_oe_kurzbz, student_stg.oe_kurzbz student_stg_oe_kurzbz
|
|
FROM
|
|
public.tbl_prestudent pre
|
|
JOIN public.tbl_student stud USING(prestudent_id)
|
|
JOIN public.tbl_person pers USING(person_id)
|
|
JOIN public.tbl_studiengang stg ON pre.studiengang_kz = stg.studiengang_kz
|
|
JOIN public.tbl_studiengang student_stg ON stud.studiengang_kz = student_stg.studiengang_kz
|
|
WHERE
|
|
stud.studiengang_kz != pre.studiengang_kz";
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND stg.studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
if (isset($prestudent_id))
|
|
{
|
|
$qry .= " AND pre.prestudent_id = ?";
|
|
$params[] = $prestudent_id;
|
|
}
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
/**
|
|
* Orgform of a Studiengang in Studienplan should be the same as orgform of student.
|
|
* @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param prestudent_id int if check is to be executed only for one prestudent
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getOrgformStgUngleichOrgformPrestudent($studiensemester_kurzbz, $studiengang_kz = null, $prestudent_id = null)
|
|
{
|
|
$params = array($studiensemester_kurzbz);
|
|
|
|
$qry = "
|
|
SELECT
|
|
prestudent.person_id, prestudent.prestudent_id, status.studiensemester_kurzbz,
|
|
studiengang.orgform_kurzbz AS stg_orgform, status.orgform_kurzbz AS student_orgform,
|
|
prestudent.studiengang_kz AS student_studiengang, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz
|
|
FROM
|
|
public.tbl_studiengang studiengang
|
|
JOIN public.tbl_student student USING(studiengang_kz)
|
|
JOIN public.tbl_prestudent prestudent USING(prestudent_id)
|
|
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
|
|
JOIN public.tbl_benutzer benutzer on(benutzer.uid = student.student_uid)
|
|
JOIN public.tbl_studiengang stg ON prestudent.studiengang_kz = stg.studiengang_kz
|
|
LEFT JOIN lehre.tbl_studienplan stpl USING (studienplan_id)
|
|
WHERE
|
|
benutzer.aktiv = true
|
|
AND status.status_kurzbz IN ('Student', 'Unterbrecher', 'Abbrecher', 'Diplomand', 'Absolvent')
|
|
AND studiengang.studiengang_kz < 10000
|
|
AND status.studiensemester_kurzbz = ?
|
|
AND NOT (status.orgform_kurzbz IS NULL AND studiengang.mischform = FALSE)
|
|
AND NOT EXISTS(
|
|
SELECT 1
|
|
FROM
|
|
lehre.tbl_studienplan
|
|
JOIN
|
|
lehre.tbl_studienordnung USING(studienordnung_id)
|
|
WHERE
|
|
tbl_studienplan.studienplan_id = stpl.studienplan_id
|
|
AND tbl_studienordnung.studiengang_kz = prestudent.studiengang_kz
|
|
AND tbl_studienplan.orgform_kurzbz = status.orgform_kurzbz)";
|
|
|
|
if (isset($prestudent_id))
|
|
{
|
|
$qry .= " AND prestudent.prestudent_id = ?";
|
|
$params[] = $prestudent_id;
|
|
}
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND studiengang.studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
$qry .= "
|
|
ORDER BY student_uid";
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
/**
|
|
* Students in "mixed" Studiengang should have Orgform.
|
|
* @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param prestudent_id int if check is to be executed only for one prestudent
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getPrestudentMischformOhneOrgform($studiensemester_kurzbz, $studiengang_kz = null, $prestudent_id = null)
|
|
{
|
|
$params = array($studiensemester_kurzbz);
|
|
|
|
$qry = "
|
|
SELECT
|
|
pre.person_id, pre.prestudent_id, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz, status.studiensemester_kurzbz
|
|
FROM
|
|
public.tbl_prestudent pre
|
|
JOIN public.tbl_person USING(person_id)
|
|
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
|
|
JOIN public.tbl_studiengang stg USING(studiengang_kz)
|
|
WHERE
|
|
status.status_kurzbz IN ('Bewerber', 'Student')
|
|
AND stg.mischform
|
|
AND (status.orgform_kurzbz='' OR status.orgform_kurzbz IS NULL)
|
|
AND status.studiensemester_kurzbz=?";
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND stg.studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
if (isset($prestudent_id))
|
|
{
|
|
$qry .= " AND pre.prestudent_id = ?";
|
|
$params[] = $prestudent_id;
|
|
}
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
/**
|
|
* Studiengang should be the same for prestudent and studienplan.
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param prestudent_id int if check is to be executed only for one prestudent
|
|
* @param studienordnung_id int if check is to be executed only for a certain studienordnung_id
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getStgPrestudentUngleichStgStudienplan($studiengang_kz = null, $prestudent_id = null, $studienordnung_id = null)
|
|
{
|
|
$params = array();
|
|
|
|
$qry = "
|
|
SELECT
|
|
DISTINCT ON (ps.prestudent_id) ps.person_id, ps.prestudent_id, stordnung.studienordnung_id,
|
|
stplan.bezeichnung AS studienplan, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz
|
|
FROM
|
|
public.tbl_prestudent ps
|
|
JOIN public.tbl_prestudentstatus USING(prestudent_id)
|
|
JOIN lehre.tbl_studienplan stplan USING(studienplan_id)
|
|
JOIN lehre.tbl_studienordnung stordnung USING(studienordnung_id)
|
|
JOIN public.tbl_person USING(person_id)
|
|
JOIN public.tbl_studiengang stg ON ps.studiengang_kz = stg.studiengang_kz
|
|
WHERE
|
|
ps.studiengang_kz<>stordnung.studiengang_kz
|
|
AND stg.melderelevant";
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND stg.studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
if (isset($prestudent_id))
|
|
{
|
|
$qry .= " AND ps.prestudent_id = ?";
|
|
$params[] = $prestudent_id;
|
|
}
|
|
|
|
if (isset($studienordnung_id))
|
|
{
|
|
$qry .= " AND stordnung.studienordnung_id = ?";
|
|
$params[] = $studienordnung_id;
|
|
}
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------------------------------
|
|
// Studentstatus checks
|
|
|
|
/**
|
|
* Abbrecher cannot be active.
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param prestudent_id int if check is to be executed only for one prestudent
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getAbbrecherAktiv($studiengang_kz = null, $prestudent_id = null)
|
|
{
|
|
$params = array();
|
|
|
|
$qry = "
|
|
SELECT
|
|
pre.person_id, pre.prestudent_id, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz
|
|
FROM
|
|
public.tbl_prestudentstatus pre_status
|
|
JOIN public.tbl_prestudent pre USING(prestudent_id)
|
|
JOIN public.tbl_student student USING(prestudent_id)
|
|
JOIN public.tbl_benutzer benutzer on(benutzer.uid=student.student_uid)
|
|
JOIN public.tbl_studiengang stg ON pre.studiengang_kz = stg.studiengang_kz
|
|
WHERE
|
|
pre_status.status_kurzbz ='Abbrecher'
|
|
AND benutzer.aktiv=true";
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND stg.studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
if (isset($prestudent_id))
|
|
{
|
|
$qry .= " AND pre.prestudent_id = ?";
|
|
$params[] = $prestudent_id;
|
|
}
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
/**
|
|
* There shouldn't be any status after Abbrecher status.
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param prestudent_id int if check is to be executed only for one prestudent
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getStudentstatusNachAbbrecher($studiengang_kz = null, $prestudent_id = null)
|
|
{
|
|
$params = array();
|
|
|
|
$qry = "
|
|
SELECT
|
|
prestudent.person_id, prestudent.prestudent_id, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz
|
|
FROM
|
|
public.tbl_student student
|
|
JOIN public.tbl_prestudent prestudent USING(prestudent_id)
|
|
JOIN public.tbl_prestudentstatus prestatus USING(prestudent_id)
|
|
JOIN public.tbl_studiengang stg ON prestudent.studiengang_kz = stg.studiengang_kz
|
|
WHERE
|
|
prestatus.status_kurzbz = 'Abbrecher'
|
|
AND get_rolle_prestudent(prestudent.prestudent_id, prestatus.studiensemester_kurzbz) <> 'Abbrecher'";
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND stg.studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
if (isset($prestudent_id))
|
|
{
|
|
$qry .= " AND prestudent.prestudent_id = ?";
|
|
$params[] = $prestudent_id;
|
|
}
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
/**
|
|
* Ausbildungssemester of prestudent (lehrverband) must be the same as Ausbildungssemester of prestudentstatus.
|
|
* @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param prestudent_id int if check is to be executed only for one prestudent
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getAusbildungssemPrestudentUngleichAusbildungssemStatus($studiensemester_kurzbz, $studiengang_kz = null, $prestudent_id = null)
|
|
{
|
|
$params = array($studiensemester_kurzbz, $studiensemester_kurzbz, $studiensemester_kurzbz);
|
|
|
|
$qry = "
|
|
SELECT
|
|
DISTINCT(student.student_uid), student.student_uid, prestudent.person_id, prestudent.prestudent_id,
|
|
status.ausbildungssemester AS status_ausbildungssemester, lv.semester AS student_ausbildungssemester, status.studiensemester_kurzbz,
|
|
stg.oe_kurzbz AS prestudent_stg_oe_kurzbz
|
|
FROM
|
|
public.tbl_student student
|
|
JOIN public.tbl_studentlehrverband lv USING(student_uid)
|
|
JOIN public.tbl_prestudent prestudent USING(prestudent_id)
|
|
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
|
|
JOIN public.tbl_studiengang stg ON prestudent.studiengang_kz = stg.studiengang_kz
|
|
WHERE
|
|
status.studiensemester_kurzbz = ?
|
|
AND lv.studiensemester_kurzbz = ?
|
|
AND status.status_kurzbz NOT IN ('Interessent','Bewerber','Aufgenommener','Wartender','Abgewiesener','Unterbrecher')
|
|
AND get_rolle_prestudent (prestudent_id, ?)='Student'
|
|
AND status.ausbildungssemester != lv.semester";
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND stg.studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
if (isset($prestudent_id))
|
|
{
|
|
$qry .= " AND prestudent.prestudent_id = ?";
|
|
$params[] = $prestudent_id;
|
|
}
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
/**
|
|
* Students with active status should have an active Benutzer.
|
|
* @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param prestudent_id int if check is to be executed only for one prestudent
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getInaktiverStudentAktiverStatus($studiensemester_kurzbz, $studiengang_kz = null, $prestudent_id = null)
|
|
{
|
|
$aktStudiensemesterRes = $this->_ci->StudiensemesterModel->getAkt();
|
|
|
|
if (isError($aktStudiensemesterRes)) return $aktStudiensemesterRes;
|
|
|
|
$studiensemester_kurzbz = hasData($aktStudiensemesterRes) ? getData($aktStudiensemesterRes)[0]->studiensemester_kurzbz : '';
|
|
|
|
$params = array($studiensemester_kurzbz);
|
|
|
|
$qry = "
|
|
SELECT
|
|
DISTINCT(student.student_uid), prestudent.person_id, prestudent.prestudent_id, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz
|
|
FROM
|
|
public.tbl_benutzer benutzer
|
|
JOIN public.tbl_student student on(benutzer.uid = student.student_uid)
|
|
JOIN public.tbl_prestudent prestudent USING(prestudent_id)
|
|
JOIN public.tbl_studiengang stg ON prestudent.studiengang_kz = stg.studiengang_kz
|
|
WHERE
|
|
benutzer.aktiv=false
|
|
AND EXISTS (SELECT 1 FROM public.tbl_prestudentstatus WHERE prestudent_id = prestudent.prestudent_id AND studiensemester_kurzbz = ?)
|
|
AND get_rolle_prestudent(prestudent_id, NULL) IN ('Student', 'Diplomand', 'Unterbrecher', 'Praktikant')
|
|
AND stg.melderelevant
|
|
AND prestudent.bismelden";
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND stg.studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
if (isset($prestudent_id))
|
|
{
|
|
$qry .= " AND prestudent.prestudent_id = ?";
|
|
$params[] = $prestudent_id;
|
|
}
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
/**
|
|
* Students of a semester shouldn't start studies before the date of Bismeldung.
|
|
* e.g. If student studies in WS2022 datum of status shouldn't be before 15.4.2020
|
|
* e.g. If student studies in SS2022 datum of status shouldn't be before 15.11.2022
|
|
* @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param prestudent_id int if check is to be executed only for one prestudent
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getInskriptionVorLetzerBismeldung($studiensemester_kurzbz, $studiengang_kz = null, $prestudent_id = null)
|
|
{
|
|
// get Bismeldedatum
|
|
$datumBis = $this->_getBisdateFromSemester($studiensemester_kurzbz);
|
|
|
|
$params = array($datumBis, $studiensemester_kurzbz, $datumBis);
|
|
|
|
// get active students
|
|
$qry = "
|
|
SELECT
|
|
DISTINCT ON (student.student_uid) ? AS datum_bismeldung,
|
|
prestudent.person_id, prestudent.prestudent_id, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz, status.studiensemester_kurzbz
|
|
FROM
|
|
public.tbl_benutzer benutzer
|
|
JOIN public.tbl_student student on(benutzer.uid = student.student_uid)
|
|
JOIN public.tbl_prestudent prestudent USING(prestudent_id)
|
|
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
|
|
JOIN public.tbl_studiengang stg ON prestudent.studiengang_kz = stg.studiengang_kz
|
|
WHERE
|
|
benutzer.aktiv=true
|
|
AND status.studiensemester_kurzbz = ?
|
|
/* inscription date before date of first student status */
|
|
AND (
|
|
SELECT datum
|
|
FROM public.tbl_prestudentstatus
|
|
WHERE prestudent_id = prestudent.prestudent_id
|
|
AND studiensemester_kurzbz = status.studiensemester_kurzbz
|
|
AND status_kurzbz = 'Student'
|
|
ORDER BY datum, insertamum, ext_id
|
|
LIMIT 1
|
|
) < ?
|
|
AND stg.melderelevant
|
|
AND prestudent.bismelden";
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND stg.studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
if (isset($prestudent_id))
|
|
{
|
|
$qry .= " AND prestudent.prestudent_id = ?";
|
|
$params[] = $prestudent_id;
|
|
}
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
/**
|
|
* Status Dates and status studysemester dates should be in correct order.
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param prestudent_id int if check is to be executed only for one prestudent
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getDatumStudiensemesterFalscheReihenfolge($studiengang_kz = null, $prestudent_id = null)
|
|
{
|
|
$params = array();
|
|
|
|
// all active students with Status student in current semester
|
|
$qry = "
|
|
SELECT DISTINCT ON (prestudent_id) *
|
|
FROM (
|
|
SELECT
|
|
prestudent.person_id, prestudent.prestudent_id,
|
|
stg.studiengang_kz, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz,
|
|
ROW_NUMBER () OVER (
|
|
PARTITION BY prestudent.prestudent_id
|
|
ORDER BY sem.start DESC, status.datum DESC, status.insertamum DESC, status.ext_id DESC
|
|
) AS reihenfolge_semester,
|
|
ROW_NUMBER () OVER (
|
|
PARTITION BY prestudent.prestudent_id
|
|
ORDER BY status.datum DESC, status.insertamum DESC, status.ext_id DESC
|
|
) AS reihenfolge_datum
|
|
FROM
|
|
public.tbl_student student
|
|
JOIN public.tbl_benutzer benutzer on(student.student_uid = benutzer.uid)
|
|
JOIN public.tbl_prestudent prestudent USING(prestudent_id)
|
|
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
|
|
JOIN public.tbl_studiensemester sem USING(studiensemester_kurzbz)
|
|
JOIN public.tbl_studiengang stg ON prestudent.studiengang_kz = stg.studiengang_kz
|
|
WHERE
|
|
benutzer.aktiv=true
|
|
AND status.status_kurzbz='Student'
|
|
) reihenfolge
|
|
WHERE reihenfolge_semester <> reihenfolge_datum";
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
if (isset($prestudent_id))
|
|
{
|
|
$qry .= " AND prestudent_id = ?";
|
|
$params[] = $prestudent_id;
|
|
}
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
/**
|
|
* Students with active Benutzer should have a status in the current semester.
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param prestudent_id int if check is to be executed only for one prestudent
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getAktiverStudentOhneStatus($studiengang_kz = null, $prestudent_id = null)
|
|
{
|
|
$params = array();
|
|
|
|
$qry = "
|
|
SELECT
|
|
DISTINCT (student_uid), prestudent.person_id, prestudent.prestudent_id, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz
|
|
FROM
|
|
public.tbl_student student
|
|
JOIN public.tbl_benutzer benutzer on (benutzer.uid = student.student_uid)
|
|
JOIN public.tbl_prestudent prestudent USING(prestudent_id)
|
|
JOIN public.tbl_studiengang stg ON prestudent.studiengang_kz = stg.studiengang_kz
|
|
WHERE
|
|
benutzer.aktiv=TRUE
|
|
AND stg.melderelevant
|
|
AND prestudent.bismelden
|
|
AND NOT EXISTS (
|
|
SELECT 1
|
|
FROM public.tbl_prestudentstatus
|
|
JOIN public.tbl_studiensemester sem USING (studiensemester_kurzbz)
|
|
WHERE prestudent_id = prestudent.prestudent_id
|
|
/* buffer of four months, as status are often entered later */
|
|
AND sem.ende::date > NOW() - interval '4 months'
|
|
)";
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND stg.studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
if (isset($prestudent_id))
|
|
{
|
|
$qry .= " AND prestudent.prestudent_id = ?";
|
|
$params[] = $prestudent_id;
|
|
}
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
/**
|
|
* Studienplan should be valid in current Ausbildungssemester of prestudent.
|
|
* @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param prestudent_id int if check is to be executed only for one prestudent
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getStudienplanUngueltig($studiensemester_kurzbz, $studiengang_kz = null, $prestudent_id = null)
|
|
{
|
|
$params = array($studiensemester_kurzbz);
|
|
|
|
$qry = "
|
|
SELECT
|
|
DISTINCT pre.person_id, pre.prestudent_id,
|
|
tbl_studienplan.bezeichnung AS studienplan,
|
|
status.status_kurzbz,
|
|
status.studiensemester_kurzbz,
|
|
status.ausbildungssemester,
|
|
stg.oe_kurzbz AS prestudent_stg_oe_kurzbz
|
|
FROM
|
|
public.tbl_prestudent pre
|
|
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
|
|
JOIN public.tbl_person USING(person_id)
|
|
JOIN lehre.tbl_studienplan USING(studienplan_id)
|
|
JOIN public.tbl_studiengang stg ON pre.studiengang_kz = stg.studiengang_kz
|
|
WHERE
|
|
status_kurzbz in('Student', 'Interessent','Bewerber','Aufgenommener')
|
|
AND NOT EXISTS (
|
|
SELECT
|
|
1
|
|
FROM
|
|
lehre.tbl_studienplan_semester
|
|
WHERE
|
|
studienplan_id=status.studienplan_id
|
|
AND tbl_studienplan_semester.semester = status.ausbildungssemester
|
|
AND tbl_studienplan_semester.studiensemester_kurzbz = status.studiensemester_kurzbz
|
|
)
|
|
AND status.studiensemester_kurzbz=?
|
|
AND pre.bismelden
|
|
AND stg.melderelevant";
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND stg.studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
if (isset($prestudent_id))
|
|
{
|
|
$qry .= " AND tbl_prestudent.prestudent_id = ?";
|
|
$params[] = $prestudent_id;
|
|
}
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
/**
|
|
* Students with finished studies should have exactly one final exam.
|
|
* @param studiensemester_kurzbz string if check is to be executed for certain Studiensemester
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param prestudent_id int if check is to be executed only for one prestudent
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getFalscheAnzahlAbschlusspruefungen($studiensemester_kurzbz = null, $studiengang_kz = null, $prestudent_id = null)
|
|
{
|
|
$params = array();
|
|
|
|
$qry = "
|
|
SELECT * FROM (
|
|
SELECT
|
|
DISTINCT ON(pre.prestudent_id) pre.person_id, pre.prestudent_id, student_uid, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz,
|
|
(
|
|
SELECT COUNT(*)
|
|
FROM lehre.tbl_abschlusspruefung
|
|
WHERE student_uid = stud.student_uid
|
|
AND abschlussbeurteilung_kurzbz != 'nicht'
|
|
AND abschlussbeurteilung_kurzbz IS NOT NULL
|
|
) AS anzahl_abschlusspruefungen
|
|
FROM
|
|
public.tbl_prestudent pre
|
|
JOIN public.tbl_student stud USING(prestudent_id)
|
|
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
|
|
JOIN public.tbl_studiengang stg ON pre.studiengang_kz = stg.studiengang_kz
|
|
WHERE
|
|
status_kurzbz = 'Absolvent'
|
|
AND pre.bismelden
|
|
AND stg.melderelevant
|
|
AND NOT EXISTS ( /* exclude gs */
|
|
SELECT 1
|
|
FROM bis.tbl_mobilitaet
|
|
WHERE prestudent_id = pre.prestudent_id
|
|
AND studiensemester_kurzbz = status.studiensemester_kurzbz
|
|
)";
|
|
|
|
if (isset($studiensemester_kurzbz))
|
|
{
|
|
$qry .= " AND status.studiensemester_kurzbz = ?";
|
|
$params[] = $studiensemester_kurzbz;
|
|
}
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND stg.studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
if (isset($prestudent_id))
|
|
{
|
|
$qry .= " AND pre.prestudent_id = ?";
|
|
$params[] = $prestudent_id;
|
|
}
|
|
|
|
$qry .= ") studenten
|
|
WHERE anzahl_abschlusspruefungen != 1";
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
/**
|
|
* Date of final exam shouldn't be missing for Absolvent.
|
|
* @param studiensemester_kurzbz string if check is to be executed for certain Studiensemester
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param abschlusspruefung_id int if check is to be executed for a certain Abschlussprüfung
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getDatumAbschlusspruefungFehlt($studiensemester_kurzbz = null, $studiengang_kz = null, $abschlusspruefung_id = null)
|
|
{
|
|
$results = array();
|
|
|
|
$pruefungenRes = $this->_getInvalidAbschlusspruefungen($studiensemester_kurzbz, $studiengang_kz, $abschlusspruefung_id);
|
|
|
|
if (isError($pruefungenRes)) return $pruefungenRes;
|
|
|
|
if (hasData($pruefungenRes))
|
|
{
|
|
$pruefungen = getData($pruefungenRes);
|
|
|
|
foreach ($pruefungen as $pruefung)
|
|
{
|
|
if (isEmptyString($pruefung->datum)) $results[] = $pruefung;
|
|
}
|
|
}
|
|
|
|
return success($results);
|
|
}
|
|
|
|
/**
|
|
* Date of sponsion shouldn't be missing for Absolvent.
|
|
* @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param abschlusspruefung_id int if check is to be executed only for a certain Abschlussprüfung
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getDatumSponsionFehlt($studiensemester_kurzbz = null, $studiengang_kz = null, $abschlusspruefung_id = null)
|
|
{
|
|
$results = array();
|
|
|
|
$pruefungenRes = $this->_getInvalidAbschlusspruefungen($studiensemester_kurzbz, $studiengang_kz, $abschlusspruefung_id);
|
|
|
|
if (isError($pruefungenRes)) return $pruefungenRes;
|
|
|
|
if (hasData($pruefungenRes))
|
|
{
|
|
$pruefungen = getData($pruefungenRes);
|
|
|
|
foreach ($pruefungen as $pruefung)
|
|
{
|
|
if (isEmptyString($pruefung->sponsion)) $results[] = $pruefung;
|
|
}
|
|
}
|
|
|
|
return success($results);
|
|
}
|
|
|
|
/**
|
|
* Bewerber should have participated in Reihungstest.
|
|
* @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param prestudent_id int if check is to be executed only for one prestudent
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getBewerberNichtZumRtAngetreten($studiensemester_kurzbz, $studiengang_kz = null, $prestudent_id = null)
|
|
{
|
|
$previousStudiensemesterRes = $this->_ci->StudiensemesterModel->getPreviousFrom($studiensemester_kurzbz);
|
|
|
|
if (isError($previousStudiensemesterRes)) return $previousStudiensemesterRes;
|
|
|
|
$params = array($studiensemester_kurzbz);
|
|
|
|
$qry = "
|
|
SELECT
|
|
prestudent.person_id, prestudent.prestudent_id, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz, status.studiensemester_kurzbz
|
|
FROM
|
|
public.tbl_prestudent prestudent
|
|
JOIN public.tbl_prestudentstatus status ON(prestudent.prestudent_id=status.prestudent_id)
|
|
JOIN public.tbl_person USING(person_id)
|
|
LEFT JOIN bis.tbl_orgform USING(orgform_kurzbz)
|
|
JOIN public.tbl_studiengang stg USING(studiengang_kz)
|
|
WHERE
|
|
status_kurzbz='Bewerber'
|
|
AND reihungstestangetreten=false
|
|
AND stg.melderelevant
|
|
AND prestudent.bismelden";
|
|
|
|
if (hasData($previousStudiensemesterRes))
|
|
{
|
|
$previousStudiensemester = getData($previousStudiensemesterRes)[0]->studiensemester_kurzbz;
|
|
$qry .= " AND (studiensemester_kurzbz=? OR studiensemester_kurzbz=?)";
|
|
$params[] = $previousStudiensemester;
|
|
}
|
|
else
|
|
{
|
|
$qry .= " AND studiensemester_kurzbz=?";
|
|
}
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND stg.studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
if (isset($prestudent_id))
|
|
{
|
|
$qry .= " AND prestudent.prestudent_id = ?";
|
|
$params[] = $prestudent_id;
|
|
}
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
/**
|
|
* Current Ausbildungssemester shouldn't be 0.
|
|
* @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param prestudent_id int if check is to be executed only for one prestudent
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getAktSemesterNull($studiensemester_kurzbz, $studiengang_kz = null, $prestudent_id = null)
|
|
{
|
|
$params = array($studiensemester_kurzbz);
|
|
|
|
$qry = "
|
|
SELECT
|
|
DISTINCT pre.person_id, pre.prestudent_id, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz, prestat.studiensemester_kurzbz
|
|
FROM
|
|
public.tbl_prestudent pre
|
|
JOIN public.tbl_prestudentstatus prestat USING(prestudent_id)
|
|
JOIN public.tbl_studiengang stg USING(studiengang_kz)
|
|
WHERE
|
|
prestat.status_kurzbz != 'Incoming'
|
|
AND prestat.studiensemester_kurzbz = ?
|
|
AND ausbildungssemester = 0
|
|
AND stg.melderelevant
|
|
AND pre.bismelden";
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND stg.studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
if (isset($prestudent_id))
|
|
{
|
|
$qry .= " AND pre.prestudent_id = ?";
|
|
$params[] = $prestudent_id;
|
|
}
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
/**
|
|
* Prestudent should have a final status.
|
|
* @param studiensemester_kurzbz string if check is to be executed for certain Studiensemester
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param prestudent_id int if check is to be executed only for one prestudent
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getAbschlussstatusFehlt($studiensemester_kurzbz = null, $studiengang_kz = null, $prestudent_id = null)
|
|
{
|
|
$params = array();
|
|
|
|
$qry = "
|
|
SELECT
|
|
DISTINCT ON (pre.prestudent_id)
|
|
pre.person_id, pre.prestudent_id, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz, status.studiensemester_kurzbz
|
|
FROM
|
|
public.tbl_prestudent pre
|
|
JOIN public.tbl_person USING(person_id)
|
|
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
|
|
JOIN public.tbl_studiengang stg USING(studiengang_kz)
|
|
WHERE
|
|
NOT EXISTS( /*student does not study anymore*/
|
|
SELECT
|
|
1
|
|
FROM
|
|
public.tbl_prestudentstatus ps
|
|
JOIN public.tbl_studiensemester USING(studiensemester_kurzbz)
|
|
WHERE
|
|
prestudent_id=pre.prestudent_id
|
|
/* 4 months: There might be Diplomanden, in summer months end status is often not entered yet */
|
|
AND tbl_studiensemester.ende>now() - interval '4 months'
|
|
)
|
|
/* check only valid begininng with 2018 */
|
|
AND '2018-01-01'<(SELECT max(datum) FROM public.tbl_prestudentstatus WHERE prestudent_id=pre.prestudent_id)
|
|
AND NOT EXISTS( /* no end status */
|
|
SELECT 1
|
|
FROM public.tbl_prestudentstatus ps
|
|
WHERE
|
|
prestudent_id=pre.prestudent_id
|
|
AND status_kurzbz IN('Abbrecher','Abgewiesener','Absolvent','Incoming')
|
|
)
|
|
AND stg.melderelevant
|
|
AND pre.bismelden";
|
|
|
|
if (isset($studiensemester_kurzbz))
|
|
{
|
|
$prevStudiensemesterRes = $this->_ci->StudiensemesterModel->getPreviousFrom($studiensemester_kurzbz);
|
|
|
|
if (isError($prevStudiensemesterRes)) return $prevStudiensemesterRes;
|
|
|
|
if (hasData($prevStudiensemesterRes))
|
|
{
|
|
// if Studiensemester given, check only if has status in current or previous semester
|
|
$prevStudiensemester = getData($prevStudiensemesterRes)[0]->studiensemester_kurzbz;
|
|
$qry .= " AND EXISTS (
|
|
SELECT 1
|
|
FROM public.tbl_prestudentstatus ps
|
|
WHERE studiensemester_kurzbz IN (?, ?)
|
|
AND ps.prestudent_id = pre.prestudent_id
|
|
)";
|
|
$params[] = $prevStudiensemester;
|
|
$params[] = $studiensemester_kurzbz;
|
|
}
|
|
}
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND stg.studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
if (isset($prestudent_id))
|
|
{
|
|
$qry .= " AND pre.prestudent_id = ?";
|
|
$params[] = $prestudent_id;
|
|
}
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
/**
|
|
* Student with active status should have been charged, i.e. have a Kontobuchung with a negative or zero value.
|
|
* @param studiensemester_kurzbz string if check is to be executed for certain Studiensemester
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param prestudent_id int if check is to be executed only for one prestudent
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getAktiverStudentstatusOhneKontobuchung($studiensemester_kurzbz, $studiengang_kz = null, $prestudent_id = null)
|
|
{
|
|
$params = array($studiensemester_kurzbz);
|
|
|
|
$qry = "
|
|
SELECT
|
|
DISTINCT ON (pre.prestudent_id)
|
|
pre.person_id, pre.prestudent_id, stg.oe_kurzbz AS prestudent_stg_oe_kurzbz, status.studiensemester_kurzbz
|
|
FROM
|
|
public.tbl_prestudent pre
|
|
JOIN public.tbl_person pers USING(person_id)
|
|
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
|
|
JOIN public.tbl_studiengang stg USING(studiengang_kz)
|
|
WHERE
|
|
status.studiensemester_kurzbz = ?
|
|
AND status.status_kurzbz IN ('Student', 'Incoming')
|
|
AND NOT EXISTS (
|
|
SELECT 1
|
|
FROM
|
|
public.tbl_konto
|
|
WHERE
|
|
person_id = pers.person_id
|
|
AND studiensemester_kurzbz = status.studiensemester_kurzbz
|
|
AND buchungsnr_verweis IS NULL
|
|
AND betrag <= 0
|
|
)
|
|
AND stg.melderelevant
|
|
AND pre.bismelden";
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND stg.studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
if (isset($prestudent_id))
|
|
{
|
|
$qry .= " AND pre.prestudent_id = ?";
|
|
$params[] = $prestudent_id;
|
|
}
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------------------------------
|
|
// Person checks
|
|
|
|
/**
|
|
* Birthdate is too long ago.
|
|
* @param studiensemester_kurzbz string if check is to be executed for certain Studiensemester
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param person_id int if check is to be executed only for one person
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getGbDatumWeitZurueck($studiensemester_kurzbz = null, $studiengang_kz = null, $person_id = null)
|
|
{
|
|
$params = array();
|
|
|
|
$qry = "
|
|
SELECT
|
|
pers.person_id
|
|
FROM
|
|
public.tbl_person pers
|
|
WHERE
|
|
pers.gebdatum < '1920-01-01'
|
|
AND EXISTS (
|
|
SELECT 1
|
|
FROM public.tbl_prestudent
|
|
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
|
|
JOIN public.tbl_studiengang stg USING(studiengang_kz)
|
|
WHERE person_id = pers.person_id";
|
|
|
|
if (isset($studiensemester_kurzbz))
|
|
{
|
|
$qry .= " AND status.studiensemester_kurzbz = ?";
|
|
$params[] = $studiensemester_kurzbz;
|
|
}
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND stg.studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
$qry .= ")";
|
|
|
|
if (isset($person_id))
|
|
{
|
|
$qry .= " AND pers.person_id = ?";
|
|
$params[] = $person_id;
|
|
}
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
/**
|
|
* Nation is not Austria, but address has austrian Gemeinde.
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param person_id int if check is to be executed only for one person
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getNationNichtOesterreichAberGemeinde($studiengang_kz = null, $person_id = null)
|
|
{
|
|
$params = array();
|
|
|
|
$qry = "SELECT DISTINCT tbl_person.person_id, adr.gemeinde, adr.adresse_id
|
|
FROM
|
|
public.tbl_adresse adr
|
|
JOIN public.tbl_prestudent USING(person_id)
|
|
JOIN public.tbl_person USING(person_id)
|
|
JOIN public.tbl_student USING(prestudent_id)
|
|
JOIN public.tbl_benutzer ON(uid=student_uid)
|
|
JOIN public.tbl_studiengang stg ON tbl_prestudent.studiengang_kz = stg.studiengang_kz
|
|
WHERE
|
|
adr.nation!='A'
|
|
AND tbl_benutzer.aktiv
|
|
AND gemeinde NOT IN ('Münster')
|
|
AND EXISTS(SELECT 1 FROM bis.tbl_gemeinde WHERE name = adr.gemeinde)";
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND stg.studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
if (isset($person_id))
|
|
{
|
|
$qry .= " AND tbl_person.person_id = ?";
|
|
$params[] = $person_id;
|
|
}
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
/**
|
|
* Students should have exactly one home address.
|
|
* @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param person_id int if check is to be executed only for one person
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getFalscheAnzahlHeimatadressen($studiensemester_kurzbz = null, $studiengang_kz = null, $person_id = null)
|
|
{
|
|
$params = array();
|
|
|
|
$qry = "
|
|
SELECT
|
|
DISTINCT person_id
|
|
FROM
|
|
(
|
|
SELECT person_id, COUNT(adresse_id) AS anzahl_adressen
|
|
FROM public.tbl_adresse addr
|
|
WHERE heimatadresse IS TRUE
|
|
GROUP BY person_id
|
|
) adressen
|
|
JOIN public.tbl_person USING(person_id)
|
|
JOIN public.tbl_prestudent pre USING(person_id)
|
|
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
|
|
JOIN public.tbl_student USING(prestudent_id)
|
|
JOIN public.tbl_studiengang stg ON pre.studiengang_kz = stg.studiengang_kz
|
|
WHERE
|
|
anzahl_adressen != 1
|
|
AND stg.melderelevant
|
|
AND pre.bismelden";
|
|
|
|
if (isset($studiensemester_kurzbz))
|
|
{
|
|
$qry .= " AND status.studiensemester_kurzbz = ?";
|
|
$params[] = $studiensemester_kurzbz;
|
|
}
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND stg.studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
if (isset($person_id))
|
|
{
|
|
$qry .= " AND person_id = ?";
|
|
$params[] = $person_id;
|
|
}
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
/**
|
|
* Students should have exactly one delivery address.
|
|
* @param studiensemester_kurzbz string if check is to be executed for certain Studiensemester
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param person_id int if check is to be executed only for one person
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getFalscheAnzahlZustelladressen($studiensemester_kurzbz = null, $studiengang_kz = null, $person_id = null)
|
|
{
|
|
$params = array();
|
|
|
|
$qry = "
|
|
SELECT
|
|
DISTINCT person_id
|
|
FROM
|
|
(
|
|
SELECT person_id, COUNT(adresse_id) AS anzahl_adressen
|
|
FROM public.tbl_adresse addr
|
|
WHERE zustelladresse IS TRUE
|
|
GROUP BY person_id
|
|
) adressen
|
|
JOIN public.tbl_person USING(person_id)
|
|
JOIN public.tbl_prestudent pre USING(person_id)
|
|
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
|
|
JOIN public.tbl_student USING(prestudent_id)
|
|
JOIN public.tbl_studiengang stg ON pre.studiengang_kz = stg.studiengang_kz
|
|
WHERE
|
|
anzahl_adressen != 1
|
|
AND stg.melderelevant
|
|
AND pre.bismelden";
|
|
|
|
if (isset($studiensemester_kurzbz))
|
|
{
|
|
$qry .= " AND status.studiensemester_kurzbz = ?";
|
|
$params[] = $studiensemester_kurzbz;
|
|
}
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND stg.studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
if (isset($person_id))
|
|
{
|
|
$qry .= " AND person_id = ?";
|
|
$params[] = $person_id;
|
|
}
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------------------------------
|
|
// I/O checks
|
|
|
|
/**
|
|
* Incoming shouldn't have austrian home address.
|
|
* @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param person_id int if check is to be executed only for one person
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getIncomingHeimatNationOesterreich($studiensemester_kurzbz, $studiengang_kz = null, $person_id = null)
|
|
{
|
|
$params = array($studiensemester_kurzbz);
|
|
|
|
$qry = "
|
|
SELECT
|
|
DISTINCT pers.person_id, status.studiensemester_kurzbz
|
|
FROM
|
|
public.tbl_prestudent pre
|
|
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
|
|
JOIN public.tbl_person pers USING(person_id)
|
|
JOIN public.tbl_adresse addr USING(person_id)
|
|
JOIN public.tbl_studiengang stg USING(studiengang_kz)
|
|
WHERE
|
|
status.status_kurzbz = 'Incoming'
|
|
AND addr.nation = 'A'
|
|
AND addr.heimatadresse
|
|
AND status.studiensemester_kurzbz = ?
|
|
AND stg.melderelevant
|
|
AND pre.bismelden";
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND stg.studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
if (isset($person_id))
|
|
{
|
|
$qry .= " AND pers.person_id = ?";
|
|
$params[] = $person_id;
|
|
}
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
/**
|
|
* Incoming should have IN/OUT data.
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param prestudent_id int if check is to be executed only for one prestudent
|
|
* @return success with prestudents or error
|
|
*/
|
|
public function getIncomingOhneIoDatensatz($studiengang_kz = null, $prestudent_id = null)
|
|
{
|
|
$params = array();
|
|
|
|
$qry = "
|
|
SELECT
|
|
DISTINCT ON(student_uid, nachname, vorname)
|
|
tbl_person.person_id,
|
|
tbl_prestudent.prestudent_id,
|
|
stg.oe_kurzbz AS prestudent_stg_oe_kurzbz
|
|
FROM
|
|
public.tbl_student
|
|
JOIN public.tbl_benutzer ON(student_uid=uid)
|
|
JOIN public.tbl_person USING(person_id)
|
|
JOIN public.tbl_prestudent USING(prestudent_id)
|
|
JOIN public.tbl_prestudentstatus ON(tbl_prestudent.prestudent_id=tbl_prestudentstatus.prestudent_id)
|
|
JOIN public.tbl_studiengang stg ON(stg.studiengang_kz=tbl_student.studiengang_kz)
|
|
WHERE
|
|
bismelden=TRUE
|
|
AND status_kurzbz='Incoming' AND NOT EXISTS (SELECT 1 FROM bis.tbl_bisio WHERE student_uid=tbl_student.student_uid)
|
|
AND stg.melderelevant";
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND stg.studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
if (isset($prestudent_id))
|
|
{
|
|
$qry .= " AND tbl_prestudent.prestudent_id = ?";
|
|
$params[] = $prestudent_id;
|
|
}
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
/**
|
|
* Incoming or gemeinsame Studien students should not receive funding (not be förderrelevant).
|
|
* @param studiensemester_kurzbz string check is to be executed for certain Studiensemester
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param prestudent_id int if check is to be executed only for one prestudent
|
|
* @return object success or error
|
|
*/
|
|
public function getIncomingOrGsFoerderrelevant($studiensemester_kurzbz = null, $studiengang_kz = null, $prestudent_id = null)
|
|
{
|
|
$params = array();
|
|
|
|
$qry = "
|
|
SELECT
|
|
DISTINCT ON(prestudent_id)
|
|
pers.person_id,
|
|
ps.prestudent_id,
|
|
stg.oe_kurzbz AS prestudent_stg_oe_kurzbz
|
|
FROM
|
|
public.tbl_student stud
|
|
JOIN public.tbl_benutzer ON(student_uid=uid)
|
|
JOIN public.tbl_person pers USING(person_id)
|
|
JOIN public.tbl_prestudent ps USING(prestudent_id)
|
|
JOIN public.tbl_prestudentstatus status USING(prestudent_id)
|
|
JOIN public.tbl_studiengang stg ON(stg.studiengang_kz=stud.studiengang_kz)
|
|
WHERE
|
|
(
|
|
status.status_kurzbz = 'Incoming'
|
|
OR EXISTS (
|
|
SELECT 1
|
|
FROM
|
|
bis.tbl_mobilitaet
|
|
JOIN public.tbl_prestudent USING(prestudent_id)
|
|
WHERE
|
|
prestudent_id = ps.prestudent_id
|
|
AND gsstudientyp_kurzbz = 'Extern'
|
|
)
|
|
)
|
|
AND (ps.foerderrelevant <> FALSE OR ps.foerderrelevant IS NULL)
|
|
AND bismelden=TRUE
|
|
AND stg.melderelevant";
|
|
|
|
if (isset($studiensemester_kurzbz))
|
|
{
|
|
$qry .= " AND status.studiensemester_kurzbz = ?";
|
|
$params[] = $studiensemester_kurzbz;
|
|
}
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND stg.studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
if (isset($prestudent_id))
|
|
{
|
|
$qry .= " AND ps.prestudent_id = ?";
|
|
$params[] = $prestudent_id;
|
|
}
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------------------------------
|
|
// Private methods
|
|
|
|
/**
|
|
* Get final exams in a semester which are invalid (e.g. missing data)
|
|
* @param studiensemester_kurzbz string if check is to be executed for certain Studiengang
|
|
* @param studiengang_kz int if check is to be executed for certain Studiengang
|
|
* @param abschlusspruefung_id int if check is to be executed for certain Abschlussprüfung
|
|
*/
|
|
private function _getInvalidAbschlusspruefungen($studiensemester_kurzbz = null, $studiengang_kz = null, $abschlusspruefung_id = null)
|
|
{
|
|
$params = array();
|
|
|
|
$qry = "
|
|
SELECT
|
|
pre.person_id, pre.prestudent_id,
|
|
pruefung.sponsion, pruefung.datum, pruefung.abschlusspruefung_id,
|
|
stg.oe_kurzbz AS prestudent_stg_oe_kurzbz
|
|
FROM
|
|
public.tbl_prestudent pre
|
|
JOIN public.tbl_student stud USING(prestudent_id)
|
|
JOIN public.tbl_prestudentstatus prestatus USING(prestudent_id)
|
|
JOIN public.tbl_studiengang stg ON pre.studiengang_kz = stg.studiengang_kz
|
|
JOIN lehre.tbl_abschlusspruefung pruefung ON stud.student_uid = pruefung.student_uid
|
|
WHERE
|
|
status_kurzbz = 'Absolvent'
|
|
AND NOT EXISTS ( /* exclude gs */
|
|
SELECT 1
|
|
FROM bis.tbl_mobilitaet
|
|
WHERE prestudent_id = pre.prestudent_id
|
|
AND studiensemester_kurzbz = prestatus.studiensemester_kurzbz
|
|
)
|
|
AND abschlussbeurteilung_kurzbz!='nicht'
|
|
AND abschlussbeurteilung_kurzbz IS NOT NULL
|
|
AND (pruefung.datum IS NULL OR pruefung.sponsion IS NULL)
|
|
AND pre.bismelden
|
|
AND stg.melderelevant";
|
|
|
|
if (isset($studiensemester_kurzbz))
|
|
{
|
|
$qry .= " AND prestatus.studiensemester_kurzbz = ?";
|
|
$params[] = $studiensemester_kurzbz;
|
|
}
|
|
|
|
if (isset($studiengang_kz))
|
|
{
|
|
$qry .= " AND stg.studiengang_kz = ?";
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
if (isset($abschlusspruefung_id))
|
|
{
|
|
$qry .= " AND pruefung.abschlusspruefung_id = ?";
|
|
$params[] = $abschlusspruefung_id;
|
|
}
|
|
|
|
return $this->_db->execReadOnlyQuery($qry, $params);
|
|
}
|
|
|
|
/**
|
|
* Gets Bismeldedate from Studiensemester.
|
|
* @param studiensemester_kurzbz string
|
|
*/
|
|
private function _getBisdateFromSemester($studiensemester_kurzbz)
|
|
{
|
|
$semesterYear = substr($studiensemester_kurzbz, 2, 6);
|
|
$semesterType = substr($studiensemester_kurzbz, 0, 2);
|
|
|
|
if ($semesterType == 'SS')
|
|
{
|
|
return date_format(date_create(($semesterYear - 1)."-11-15"), 'Y-m-d');
|
|
}
|
|
|
|
if ($semesterType == 'WS')
|
|
{
|
|
return date_format(date_create($semesterYear."-04-15"), 'Y-m-d');
|
|
}
|
|
}
|
|
}
|