mirror of
https://github.com/FH-Complete/FHC-Core.git
synced 2026-10-12 15:04:04 +00:00
887 lines
25 KiB
PHP
887 lines
25 KiB
PHP
<?php
|
|
/*
|
|
* Job zur einmaligen Migration des Stundenplans
|
|
*
|
|
* Aufruf
|
|
* php index.ci.php system/MigrateKalender
|
|
*/
|
|
|
|
if (! defined('BASEPATH')) exit('No direct script access allowed');
|
|
|
|
class MigrateKalender extends CLI_Controller
|
|
{
|
|
|
|
/**
|
|
* Constructor
|
|
*/
|
|
public function __construct()
|
|
{
|
|
parent::__construct();
|
|
|
|
$this->load->model('ressource/Kalender_model', 'KalenderModel');
|
|
$this->load->model('ressource/Kalender_Lehreinheit_model', 'KalenderLehreinheitModel');
|
|
$this->load->model('ressource/Kalender_Ort_model', 'KalenderOrtModel');
|
|
$this->load->model('ressource/Stundenplandev_Kalender_model', 'SyncModel');
|
|
$this->load->model('ressource/Reservierung_Kalender_model', 'SyncReservierungModel');
|
|
$this->load->model('ressource/Kalender_Event_Teilnehmer_model', 'KalenderEventTeilnehmerModel');
|
|
$this->load->model('ressource/Kalender_Event_model', 'KalenderEventModel');
|
|
$this->load->model('organisation/Studiensemester_model', 'StudiensemesterModel');
|
|
$this->load->model('person/Benutzer_model', 'BenutzerModel');
|
|
}
|
|
|
|
/**
|
|
* Everything has a beginning
|
|
*/
|
|
public function refreshTablesAndFullMigrateOfStundenplanReservierung($von, $bis = null, $studiengang_kz = null, $ort_kurzbz = null)
|
|
{
|
|
if (defined('CI_ENVIRONMENT') && CI_ENVIRONMENT === 'production')
|
|
{
|
|
echo "This script is not allowed to run in production environment.\n";
|
|
return;
|
|
}
|
|
|
|
echo "Refreshing calendar related tables...\n";
|
|
$this->resetBeforeNewStundenplanReservierungImport();
|
|
echo "Calendar related tables refreshed successfully.\n\n";
|
|
|
|
echo "Starting full migration of Stundenplan and Reservierung from $von to " . ($bis ?? '2100-12-31') . "...\n";
|
|
$this->fullMigrateOfStundenplanReservierung($von, $bis, $studiengang_kz, $ort_kurzbz);
|
|
echo "Full migration of Stundenplan and Reservierung completed successfully.\n";
|
|
}
|
|
|
|
public function fullMigrateOfStundenplanReservierung($von, $bis = null, $studiengang_kz = null, $ort_kurzbz = null)
|
|
{
|
|
echo "Starting migration of Stundenplan from $von to " . ($bis ?? '2100-12-31') . "...\n";
|
|
$this->migrateStundenplan($von, $bis, $studiengang_kz);
|
|
echo "Stundenplan migration completed successfully.\n\n";
|
|
|
|
echo "Starting migration of Reservierung from $von to " . ($bis ?? '2100-12-31') . "...\n";
|
|
$this->migrateReservierung($von, $bis, $ort_kurzbz);
|
|
echo "Reservierung migration completed successfully.\n\n";
|
|
|
|
echo "Starting migration of Stundenplan Betriebsmittel entries...\n";
|
|
$this->migrateStundenplanBetriebsmittelEntries();
|
|
echo "Stundenplan Betriebsmittel entries migration completed successfully.\n\n";
|
|
|
|
echo "Starting to add title values as tags to calendar entries...\n";
|
|
$this->addTitleValuesAsTagsToKalenderEntries();
|
|
echo "Adding title values as tags to calendar entries completed successfully.\n\n";
|
|
}
|
|
|
|
public function migrateStundenplan($von, $bis = null, $studiengang_kz = null)
|
|
{
|
|
if (is_null($von))
|
|
return error('Parameter "von" ist erforderlich');
|
|
|
|
if (is_null($bis))
|
|
$bis = '2100-12-31';
|
|
|
|
$db = new DB_Model();
|
|
|
|
$stpldevsql = '
|
|
WITH eindeutige_stunden AS (
|
|
SELECT DISTINCT unr, datum, stunde
|
|
FROM lehre.tbl_stundenplandev
|
|
WHERE datum >= ? AND datum <= ?';
|
|
|
|
$params = [$von, $bis];
|
|
|
|
if (!is_null($studiengang_kz))
|
|
{
|
|
$stpldevsql .= ' AND studiengang_kz = ?';
|
|
|
|
$params[] = $studiengang_kz;
|
|
}
|
|
|
|
$stpldevsql .= '),
|
|
|
|
block_keys AS (
|
|
SELECT
|
|
unr,
|
|
datum,
|
|
stunde,
|
|
stunde - ROW_NUMBER() OVER (PARTITION BY unr, datum ORDER BY stunde) AS block_nr
|
|
FROM eindeutige_stunden
|
|
),
|
|
blocks AS (
|
|
SELECT
|
|
bk.unr,
|
|
bk.datum,
|
|
bk.block_nr,
|
|
MIN(bk.stunde) AS stunde_von,
|
|
MAX(bk.stunde) AS stunde_bis,
|
|
array_agg(DISTINCT sp.lehreinheit_id) AS lehreinheit_id,
|
|
array_agg(DISTINCT sp.ort_kurzbz) AS ort_kurzbz,
|
|
array_agg(sp.stundenplandev_id ORDER BY bk.stunde) AS stundenplandev_ids,
|
|
MIN(sp.insertamum) AS insertamum,
|
|
(array_agg(sp.insertvon ORDER BY sp.insertamum ASC))[1] AS insertvon,
|
|
MAX(sp.updateamum) AS updateamum,
|
|
(array_agg(sp.updatevon ORDER BY sp.updateamum DESC))[1] AS updatevon
|
|
FROM block_keys bk JOIN lehre.tbl_stundenplandev sp ON sp.unr = bk.unr AND sp.datum = bk.datum AND sp.stunde = bk.stunde
|
|
WHERE sp.datum >= ? AND sp.datum <= ?
|
|
GROUP BY bk.unr, bk.datum, bk.block_nr
|
|
)
|
|
SELECT
|
|
b.stundenplandev_ids,
|
|
b.unr,
|
|
b.datum,
|
|
b.block_nr,
|
|
b.lehreinheit_id,
|
|
b.ort_kurzbz,
|
|
b.datum + stundevon.beginn AS von,
|
|
b.datum + stundebis.ende AS bis,
|
|
b.insertamum,
|
|
b.insertvon,
|
|
b.updateamum,
|
|
b.updatevon
|
|
FROM blocks b
|
|
JOIN lehre.tbl_stunde stundevon ON stundevon.stunde = b.stunde_von
|
|
JOIN lehre.tbl_stunde stundebis ON stundebis.stunde = b.stunde_bis
|
|
ORDER BY b.datum, b.unr, b.block_nr;';
|
|
|
|
array_push($params, $von, $bis);
|
|
$stpldev = $db->execReadOnlyQuery($stpldevsql, $params);
|
|
|
|
if (hasData($stpldev))
|
|
{
|
|
// Pruefen ob der Eintrag schon in Sync Tabelle vorhanden ist
|
|
// Wenn neuere Änderungen vorhanden dann Update
|
|
// Wenn keine Änderungen seit leztem Sync dann Ueberspringen
|
|
// Wenn noch nicht vorhanden neu anlegen
|
|
// Danach ggf pruefen welceh Eintraege in der zwischenzeit geloescht wurden und
|
|
// in der neuen Tabelle auch archivieren oder loeschen
|
|
|
|
$data = getData($stpldev);
|
|
foreach($data as $block)
|
|
{
|
|
$ids = is_array($block->stundenplandev_ids) ? $block->stundenplandev_ids : explode(',', $block->stundenplandev_ids);
|
|
/*$ids = array_map('intval', $ids);*/
|
|
|
|
$this->SyncModel->db->group_start();
|
|
$where_ids_chunks = array_chunk($ids,25);
|
|
foreach($where_ids_chunks as $where_ids)
|
|
{
|
|
$this->SyncModel->db->or_where_in('stundenplandev_id', $where_ids);
|
|
}
|
|
$this->SyncModel->db->group_end();
|
|
|
|
$sync_result = $this->SyncModel->load();
|
|
|
|
if (!hasData($sync_result))
|
|
{
|
|
$kalender_id = $this->_insertKalender($block, 'lehreinheit');
|
|
if ($kalender_id)
|
|
{
|
|
$this->_insertSync($block->stundenplandev_ids, $kalender_id);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$syncData = getData($sync_result);
|
|
$kalender_id = $syncData[0]->kalender_id;
|
|
$last_sync = $syncData[0]->lastupdate;
|
|
$synced_ids = array_column($syncData, 'stundenplandev_id');
|
|
|
|
if ($block->updateamum > $last_sync)
|
|
{
|
|
$this->_updateKalender($kalender_id, $block);
|
|
$this->_updateSync($synced_ids, $kalender_id);
|
|
}
|
|
|
|
$fehlende = array_diff($block->stundenplandev_ids, $synced_ids);
|
|
if (!empty($fehlende))
|
|
{
|
|
$this->_insertSync($fehlende, $kalender_id);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public function migrateReservierung($von, $bis = null, $ort_kurzbz = null)
|
|
{
|
|
if (is_null($von))
|
|
return error('Parameter "von" ist erforderlich');
|
|
|
|
if (is_null($bis))
|
|
$bis = '2100-12-31';
|
|
|
|
$db = new DB_Model();
|
|
|
|
$qry = "WITH eindeutige_stunden AS (
|
|
SELECT DISTINCT titel, beschreibung, datum, stunde
|
|
FROM campus.tbl_reservierung
|
|
WHERE datum >= ? AND datum <= ?";
|
|
|
|
$params = array($von, $bis);
|
|
|
|
if (!is_null($ort_kurzbz))
|
|
{
|
|
$qry .= " AND ort_kurzbz = ?";
|
|
$params[] = $ort_kurzbz;
|
|
}
|
|
|
|
$qry .= "),
|
|
block_keys AS (
|
|
SELECT
|
|
titel, beschreibung, datum, stunde,
|
|
stunde - ROW_NUMBER() OVER (PARTITION BY titel, beschreibung, datum ORDER BY stunde) AS block_nr
|
|
FROM eindeutige_stunden
|
|
),
|
|
blocks AS (
|
|
SELECT
|
|
bk.titel,
|
|
bk.beschreibung,
|
|
bk.datum,
|
|
bk.block_nr,
|
|
MIN(bk.stunde) AS stunde_von,
|
|
MAX(bk.stunde) AS stunde_bis,
|
|
array_agg(DISTINCT r.reservierung_id::text) AS reservierung_ids,
|
|
array_agg(DISTINCT r.uid) AS uids,
|
|
array_agg(DISTINCT r.gruppe_kurzbz) AS gruppen_kurzbz,
|
|
array_agg(DISTINCT ROW(r.semester, r.verband, r.gruppe, r.studiengang_kz)::text) AS svg_kombis,
|
|
array_agg(DISTINCT r.ort_kurzbz) AS ort_kurzbz,
|
|
MIN(r.studiengang_kz) AS studiengang_kz,
|
|
MIN(r.reservierung_id) AS reservierung_id,
|
|
MAX(r.insertamum) AS insertamum,
|
|
(array_agg(r.insertvon ORDER BY r.insertamum ASC))[1] AS insertvon
|
|
FROM block_keys bk
|
|
JOIN campus.tbl_reservierung r
|
|
ON r.titel = bk.titel AND r.beschreibung = bk.beschreibung AND r.datum = bk.datum AND r.stunde = bk.stunde
|
|
WHERE r.datum >= ? AND r.datum <= ?
|
|
GROUP BY bk.titel, bk.beschreibung, bk.datum, bk.block_nr
|
|
)
|
|
SELECT
|
|
b.*,
|
|
(b.datum + s_von.beginn) AS von,
|
|
(b.datum + s_bis.ende) AS bis
|
|
FROM blocks b
|
|
JOIN lehre.tbl_stunde s_von ON s_von.stunde = b.stunde_von
|
|
JOIN lehre.tbl_stunde s_bis ON s_bis.stunde = b.stunde_bis
|
|
ORDER BY b.reservierung_id DESC;";
|
|
|
|
array_push($params, $von, $bis);
|
|
$reservierung_data = $db->execReadOnlyQuery($qry, $params);
|
|
|
|
|
|
if (hasData($reservierung_data))
|
|
{
|
|
$data = getData($reservierung_data);
|
|
|
|
foreach($data as $block)
|
|
{
|
|
|
|
$ids = is_array($block->reservierung_ids) ? $block->reservierung_ids : explode(',', $block->reservierung_ids);
|
|
|
|
$this->SyncReservierungModel->db->group_start();
|
|
$where_ids_chunks = array_chunk($ids,25);
|
|
foreach($where_ids_chunks as $where_ids)
|
|
{
|
|
$this->SyncReservierungModel->db->or_where_in('reservierung_id', $where_ids);
|
|
}
|
|
$this->SyncReservierungModel->db->group_end();
|
|
|
|
$sync_result = $this->SyncReservierungModel->load();
|
|
|
|
if (!hasData($sync_result))
|
|
{
|
|
$kalender_id = $this->_insertKalender($block, 'reservierung');
|
|
if ($kalender_id)
|
|
{
|
|
$this->_insertReservierungSync($block->reservierung_ids, $kalender_id);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$syncData = getData($sync_result);
|
|
$kalender_id = $syncData[0]->kalender_id;
|
|
$last_sync = $syncData[0]->lastupdate;
|
|
$synced_ids = array_column($syncData, 'reservierung_id');
|
|
|
|
if ($block->insertamum > $last_sync)
|
|
{
|
|
$this->_updateKalender($kalender_id, $block);
|
|
$this->_updateReservierungSync($synced_ids, $kalender_id);
|
|
}
|
|
|
|
$fehlende = array_diff($block->reservierung_ids, $synced_ids);
|
|
if (!empty($fehlende))
|
|
{
|
|
$this->_insertReservierungSync($fehlende, $kalender_id);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public function migrateStundenplanBetriebsmittelEntries() {
|
|
$this->setKalendarEntriesGroupIDs();
|
|
$this->setKalendarEntriesGroupIDsForChildren();
|
|
|
|
$dbModel = new DB_Model();
|
|
|
|
$deleteOldImportedTempusEntriesQuery = "DELETE from lehre.tbl_betriebsmittel_kalender WHERE quelle != 'tempus_neu' OR quelle IS NULL;";
|
|
$createHelperTypeQuery = "DO $$
|
|
BEGIN
|
|
IF NOT EXISTS (
|
|
SELECT 1
|
|
FROM pg_type
|
|
WHERE typname = 'betriebsmittel_info'
|
|
) THEN
|
|
CREATE TYPE betriebsmittel_info AS (
|
|
betriebsmittel_id bigint,
|
|
insertamum timestamp,
|
|
insertvon text
|
|
);
|
|
END IF;
|
|
END $$;";
|
|
|
|
$query = $deleteOldImportedTempusEntriesQuery .
|
|
$createHelperTypeQuery .
|
|
"WITH test AS (
|
|
SELECT
|
|
tk.eindeutige_kalender_gruppen_id AS eindeutige_kalender_gruppen_id,
|
|
array_agg(tk.kalender_id),
|
|
array_agg(
|
|
ROW(tsb.betriebsmittel_id, tsb.insertamum, tsb.insertvon)::betriebsmittel_info
|
|
) AS betriebsmittel_data
|
|
FROM sync.tbl_stundenplandev_kalender AS sk
|
|
JOIN lehre.tbl_kalender tk ON tk.kalender_id = sk.kalender_id
|
|
JOIN lehre.tbl_stundenplan_betriebsmittel tsb ON tsb.stundenplandev_id = sk.stundenplandev_id
|
|
GROUP BY tk.eindeutige_kalender_gruppen_id
|
|
)
|
|
INSERT INTO lehre.tbl_betriebsmittel_kalender (
|
|
eindeutige_kalender_gruppen_id,
|
|
betriebsmittel_id,
|
|
insertamum,
|
|
insertvon
|
|
)
|
|
SELECT
|
|
t.eindeutige_kalender_gruppen_id,
|
|
bm.betriebsmittel_id,
|
|
bm.insertamum,
|
|
bm.insertvon
|
|
FROM test t
|
|
CROSS JOIN LATERAL unnest(t.betriebsmittel_data) AS bm
|
|
ON CONFLICT (eindeutige_kalender_gruppen_id, betriebsmittel_id) DO NOTHING;
|
|
;";
|
|
|
|
$dbModel->db->query($query);
|
|
}
|
|
|
|
public function addTitleValuesAsTagsToKalenderEntries() {
|
|
$dbModel = new DB_Model();
|
|
|
|
|
|
$query = "SELECT
|
|
k.eindeutige_kalender_gruppen_id,
|
|
ARRAY_AGG(DISTINCT(spd.titel) ORDER BY spd.titel) AS titel,
|
|
MAX(spd.updateamum) AS updateamum
|
|
FROM lehre.tbl_stundenplandev spd
|
|
JOIN sync.tbl_stundenplandev_kalender spdk ON spd.stundenplandev_id = spdk.stundenplandev_id
|
|
JOIN lehre.tbl_kalender k ON k.kalender_id = spdk.kalender_id
|
|
WHERE k.typ = 'lehreinheit' AND k.eindeutige_kalender_gruppen_id IS NOT NULL AND spd.titel IS NOT NULL
|
|
GROUP BY k.eindeutige_kalender_gruppen_id";
|
|
|
|
$result = $dbModel->execReadOnlyQuery($query);
|
|
|
|
if (isError($result)) {
|
|
error("Error while fetching title values for adding as tags: " . getError($result));
|
|
return;
|
|
}
|
|
if (!hasData($result)) {
|
|
error("No title values found for adding as tags.");
|
|
return;
|
|
}
|
|
|
|
$data = getData($result);
|
|
|
|
foreach($data as $block) {
|
|
$eindeutige_kalender_gruppen_id = $block->eindeutige_kalender_gruppen_id;
|
|
$notizText = implode(' - ', array_filter($block->titel, function($titel) {
|
|
return !empty(trim($titel));
|
|
}));
|
|
|
|
if (!empty($notizText)) {
|
|
$this->addTag($eindeutige_kalender_gruppen_id, $notizText, $block->updateamum);
|
|
}
|
|
}
|
|
}
|
|
|
|
private function resetBeforeNewStundenplanReservierungImport()
|
|
{
|
|
if (defined('CI_ENVIRONMENT') && CI_ENVIRONMENT === 'production')
|
|
{
|
|
echo "This script is not allowed to run in production environment.\n";
|
|
return;
|
|
}
|
|
|
|
$db = new DB_Model();
|
|
|
|
$db->db->trans_start();
|
|
|
|
$db->db->query('DELETE FROM sync.tbl_stundenplandev_kalender');
|
|
$db->db->query('DELETE FROM sync.tbl_reservierung_kalender');
|
|
|
|
$db->db->query("DELETE FROM lehre.tbl_kalender_event_teilnehmer
|
|
WHERE kalender_id IN (
|
|
SELECT kalender_id
|
|
FROM lehre.tbl_kalender
|
|
WHERE typ = 'reservierung'
|
|
)");
|
|
|
|
$db->db->query("DELETE FROM lehre.tbl_kalender_event
|
|
WHERE kalender_id IN (
|
|
SELECT kalender_id
|
|
FROM lehre.tbl_kalender
|
|
WHERE typ = 'reservierung'
|
|
)");
|
|
|
|
$db->db->query("DELETE FROM lehre.tbl_kalender_lehreinheit
|
|
WHERE kalender_id IN (
|
|
SELECT kalender_id
|
|
FROM lehre.tbl_kalender
|
|
WHERE typ = 'lehreinheit' OR typ = 'reservierung'
|
|
)");
|
|
|
|
$db->db->query("DELETE FROM lehre.tbl_kalender_ort
|
|
WHERE kalender_id IN (
|
|
SELECT kalender_id
|
|
FROM lehre.tbl_kalender
|
|
WHERE typ IN ('lehreinheit', 'reservierung')
|
|
)");
|
|
|
|
$db->db->query("DELETE FROM public.tbl_notiz
|
|
WHERE notiz_id IN (
|
|
SELECT notiz_id
|
|
FROM lehre.tbl_kalender_notiz
|
|
WHERE eindeutige_kalender_gruppen_id IN (
|
|
SELECT eindeutige_kalender_gruppen_id
|
|
FROM lehre.tbl_kalender
|
|
)
|
|
)");
|
|
|
|
$db->db->query("DELETE FROM lehre.tbl_kalender_notiz
|
|
WHERE eindeutige_kalender_gruppen_id IN (
|
|
SELECT eindeutige_kalender_gruppen_id
|
|
FROM lehre.tbl_kalender
|
|
)");
|
|
|
|
$db->db->query("DELETE FROM lehre.tbl_betriebsmittel_kalender
|
|
WHERE eindeutige_kalender_gruppen_id IN (
|
|
SELECT eindeutige_kalender_gruppen_id
|
|
FROM lehre.tbl_kalender
|
|
)");
|
|
|
|
$db->db->query("DELETE FROM lehre.tbl_kalender
|
|
WHERE typ IN ('lehreinheit', 'reservierung')");
|
|
|
|
$db->db->trans_complete();
|
|
|
|
if ($db->db->trans_status() === false)
|
|
return error('Reset before new import failed');
|
|
|
|
return success('Migration data reset successfully');
|
|
}
|
|
|
|
private function setKalendarEntriesGroupIDs() {
|
|
$dbModel = new DB_Model();
|
|
|
|
$query = "UPDATE lehre.tbl_kalender
|
|
SET eindeutige_kalender_gruppen_id = gen_random_uuid()
|
|
WHERE vorgaenger_kalender_id IS NULL
|
|
AND eindeutige_kalender_gruppen_id IS NULL;";
|
|
|
|
$dbModel->db->query($query);
|
|
|
|
}
|
|
|
|
private function setKalendarEntriesGroupIDsForChildren() {
|
|
$dbModel = new DB_Model();
|
|
|
|
$query = "WITH RECURSIVE tree AS
|
|
(
|
|
SELECT
|
|
kalender_id,
|
|
vorgaenger_kalender_id,
|
|
kalender_id AS root_id,
|
|
eindeutige_kalender_gruppen_id as root_eindeutige_kalender_gruppen_id
|
|
FROM lehre.tbl_kalender
|
|
WHERE vorgaenger_kalender_id IS NULL
|
|
|
|
UNION ALL
|
|
|
|
SELECT
|
|
i.kalender_id,
|
|
i.vorgaenger_kalender_id,
|
|
t.root_id,
|
|
t.root_eindeutige_kalender_gruppen_id
|
|
FROM lehre.tbl_kalender i
|
|
JOIN tree t
|
|
ON i.vorgaenger_kalender_id = t.kalender_id
|
|
where i.eindeutige_kalender_gruppen_id is NULL
|
|
|
|
)
|
|
UPDATE lehre.tbl_kalender k
|
|
SET eindeutige_kalender_gruppen_id = t.root_eindeutige_kalender_gruppen_id
|
|
FROM tree t
|
|
WHERE k.kalender_id = t.kalender_id
|
|
AND k.eindeutige_kalender_gruppen_id IS NULL;";
|
|
|
|
$dbModel->db->query($query);
|
|
}
|
|
|
|
private function _insertKalender($block, $typ)
|
|
{
|
|
$result = $this->KalenderModel->insert(
|
|
array (
|
|
'von' => $block->von,
|
|
'bis' => $block->bis,
|
|
'typ' => $typ,
|
|
'status_kurzbz'=> 'live',
|
|
'insertamum' => $block->insertamum,
|
|
'insertvon' => $block->insertvon,
|
|
'updateamum' => $block->updateamum ?? null,
|
|
'updatevon' => $block->updatevon ?? null
|
|
)
|
|
);
|
|
if(!isSuccess($result))
|
|
return null;
|
|
|
|
$kalender_id = getData($result);
|
|
|
|
if ($typ === 'lehreinheit')
|
|
{
|
|
$lehreinheit_ids = is_array($block->lehreinheit_id) ? $block->lehreinheit_id : explode(',', $block->lehreinheit_id);
|
|
foreach ($lehreinheit_ids as $lehreinheit_id)
|
|
{
|
|
$leResult = $this->KalenderLehreinheitModel->insert(
|
|
array (
|
|
'kalender_id' => $kalender_id,
|
|
'lehreinheit_id'=> $lehreinheit_id
|
|
)
|
|
);
|
|
|
|
if (!isSuccess($leResult))
|
|
return null;
|
|
}
|
|
}
|
|
else if ($typ === 'reservierung')
|
|
{
|
|
$eventResult = $this->KalenderEventModel->insert(array(
|
|
'kalender_id' => $kalender_id,
|
|
'titel' => $block->titel,
|
|
'beschreibung' => $block->beschreibung
|
|
));
|
|
|
|
if (!isSuccess($eventResult))
|
|
return null;
|
|
|
|
if ($block->insertvon)
|
|
{
|
|
$user = $this->BenutzerModel->load(array('uid' => $block->insertvon));
|
|
|
|
if (hasData($user))
|
|
{
|
|
$this->KalenderEventTeilnehmerModel->insert(array(
|
|
'kalender_id' => $kalender_id,
|
|
'uid' => getData($user)[0]->uid,
|
|
'rolle_kurzbz' => 'organisator'
|
|
));
|
|
}
|
|
}
|
|
|
|
$uids = is_array($block->uids) ? $block->uids : explode(',', $block->uids);
|
|
foreach ($uids as $uid)
|
|
{
|
|
$this->KalenderEventTeilnehmerModel->insert(array(
|
|
'kalender_id' => $kalender_id,
|
|
'uid' => $uid,
|
|
'rolle_kurzbz' => 'teilnehmer'
|
|
));
|
|
}
|
|
|
|
$semester_range = $this->StudiensemesterModel->getByDateRange($block->von, $block->bis);
|
|
|
|
if (isError($semester_range))
|
|
return null;
|
|
|
|
$studiensemester_kurzbz = getData($semester_range)[0]->studiensemester_kurzbz ?? null;
|
|
|
|
$gruppen = is_array($block->gruppen_kurzbz) ? $block->gruppen_kurzbz : explode(',', $block->gruppen_kurzbz ?? '');
|
|
|
|
foreach ($gruppen as $gruppe_kurzbz)
|
|
{
|
|
$gruppe_kurzbz = trim($gruppe_kurzbz);
|
|
if (!empty($gruppe_kurzbz))
|
|
{
|
|
$this->KalenderEventTeilnehmerModel->insert(array(
|
|
'kalender_id' => $kalender_id,
|
|
'gruppe_kurzbz' => $gruppe_kurzbz,
|
|
'studiengang_kz' => $block->studiengang_kz,
|
|
'studiensemester_kurzbz' => $studiensemester_kurzbz,
|
|
'rolle_kurzbz' => 'teilnehmer'
|
|
));
|
|
}
|
|
}
|
|
|
|
foreach ($block->svg_kombis as $kombi_str)
|
|
{
|
|
$kombi_str = trim($kombi_str, '()');
|
|
list($sem, $verb, $grp, $stg_kz) = explode(',', $kombi_str);
|
|
|
|
$sem = trim($sem) === '' ? null : trim($sem);
|
|
$verb = trim($verb) === '' ? null : trim($verb);
|
|
$grp = trim($grp) === '' ? null : trim($grp);
|
|
$stg_kz = trim($stg_kz) === '' ? null : trim($stg_kz);
|
|
|
|
if (is_null($sem) && is_null($verb) && is_null($grp) && is_null($stg_kz))
|
|
continue;
|
|
|
|
$this->KalenderEventTeilnehmerModel->insert(array(
|
|
'kalender_id' => $kalender_id,
|
|
'studiengang_kz' => $stg_kz,
|
|
'semester' => $sem,
|
|
'verband' => $verb,
|
|
'gruppe' => $grp,
|
|
'studiensemester_kurzbz' => $studiensemester_kurzbz,
|
|
'rolle_kurzbz' => 'teilnehmer'
|
|
));
|
|
}
|
|
}
|
|
|
|
$orte = is_array($block->ort_kurzbz) ? $block->ort_kurzbz : explode(',', $block->ort_kurzbz ?? '');
|
|
|
|
foreach ($orte as $ort)
|
|
{
|
|
$ort = trim($ort);
|
|
if (!empty($ort))
|
|
{
|
|
$this->KalenderOrtModel->insert(
|
|
array (
|
|
'kalender_id' => $kalender_id,
|
|
'ort_kurzbz' => $ort
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
return $kalender_id;
|
|
}
|
|
|
|
private function _insertSync($ids, $kalender_id)
|
|
{
|
|
foreach($ids as $id)
|
|
{
|
|
$this->SyncModel->insert(
|
|
array (
|
|
'stundenplandev_id' => $id,
|
|
'kalender_id' => $kalender_id,
|
|
'lastupdate' => date('Y-m-d H:i:s')
|
|
)
|
|
);
|
|
}
|
|
}
|
|
private function _insertReservierungSync($ids, $kalender_id)
|
|
{
|
|
|
|
foreach($ids as $id)
|
|
{
|
|
$this->SyncReservierungModel->insert(
|
|
array (
|
|
'reservierung_id' => $id,
|
|
'kalender_id' => $kalender_id,
|
|
'lastupdate' => date('Y-m-d H:i:s')
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
private function _updateKalender($kalender_id, $block)
|
|
{
|
|
$this->KalenderModel->update(
|
|
array (
|
|
'kalender_id' => $kalender_id
|
|
),
|
|
array (
|
|
'von' => $block->von,
|
|
'bis' => $block->bis,
|
|
'updateamum'=> $block->updateamum,
|
|
'updatevon' => $block->updatevon
|
|
)
|
|
);
|
|
|
|
$orte = is_array($block->ort_kurzbz) ? $block->ort_kurzbz : explode(',', $block->ort_kurzbz ?? '');
|
|
$orte = array_filter(array_map('trim', $orte));
|
|
|
|
$this->KalenderOrtModel->delete(array('kalender_id' => $kalender_id));
|
|
|
|
foreach ($orte as $ort)
|
|
{
|
|
$this->KalenderOrtModel->insert(
|
|
array (
|
|
'kalender_id' => $kalender_id,
|
|
'ort_kurzbz' => $ort
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
private function _updateSync($ids, $kalender_id)
|
|
{
|
|
foreach($ids as $id)
|
|
{
|
|
$this->SyncModel->update(
|
|
array (
|
|
'stundenplandev_id' => $id,
|
|
'kalender_id' => $kalender_id
|
|
),
|
|
array (
|
|
'lastupdate' => date('Y-m-d H:i:s')
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
private function _updateReservierungSync($ids, $kalender_id)
|
|
{
|
|
foreach($ids as $id)
|
|
{
|
|
$this->SyncReservierungModel->update(
|
|
array (
|
|
'reservierung_id' => $id,
|
|
'kalender_id' => $kalender_id
|
|
),
|
|
array (
|
|
'lastupdate' => date('Y-m-d H:i:s')
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
private function addTag($eindeutige_kalender_gruppen_id, $notizText, $lastUpdatedInOldSystem): bool
|
|
{
|
|
$notizType = 'hinweis';
|
|
$insertvonMockUser = 'oldToNewTempusMigration';
|
|
|
|
if (is_null($eindeutige_kalender_gruppen_id) || empty($eindeutige_kalender_gruppen_id)) {
|
|
var_dump("Error: eindeutige_kalender_gruppen_id is null or empty.");
|
|
return false;
|
|
}
|
|
|
|
$this->load->model('person/Notiz_model', 'NotizModel');
|
|
$this->load->model('system/Notiztyp_model', 'NotiztypModel');
|
|
$this->load->model('ressource/KalenderNotiz_model', 'KalenderNotizModel');
|
|
|
|
$checkTyp = $this->NotiztypModel->loadWhere(array('typ_kurzbz' => $notizType));
|
|
|
|
if (isError($checkTyp))
|
|
{
|
|
error("Error occurred while checking Notiztyp: " . $checkTyp->message);
|
|
return false;
|
|
}
|
|
|
|
if (!hasData($checkTyp))
|
|
{
|
|
error("Notiztyp 'hinweis' does not exist. Please create it before adding tags.");
|
|
return false;
|
|
}
|
|
|
|
|
|
$this->KalenderNotizModel->addJoin('tbl_notiz', 'tbl_notiz.notiz_id = tbl_kalender_notiz.notiz_id', 'LEFT');
|
|
$this->KalenderNotizModel->db->where('tbl_notiz.typ', $notizType);
|
|
$this->KalenderNotizModel->db->where('tbl_notiz.insertvon', $insertvonMockUser);
|
|
$oldKalenderNotiz = $this->KalenderNotizModel->loadWhere(array('eindeutige_kalender_gruppen_id' => $eindeutige_kalender_gruppen_id));
|
|
if (isError($oldKalenderNotiz))
|
|
{
|
|
error("Error occurred while checking KalenderNotiz: " . $oldKalenderNotiz->message);
|
|
return false;
|
|
}
|
|
if (hasData($oldKalenderNotiz))
|
|
{
|
|
return $this->updateTag($eindeutige_kalender_gruppen_id, $notizText, $lastUpdatedInOldSystem);
|
|
}
|
|
|
|
|
|
$insertResult = $this->NotizModel->insert(array(
|
|
'titel' => 'TAG',
|
|
'text' => $notizText,
|
|
'verfasser_uid' => null,
|
|
'erledigt' => false,
|
|
'insertamum' => date('Y-m-d H:i:s'),
|
|
'insertvon' => $insertvonMockUser,
|
|
'typ' => $notizType
|
|
));
|
|
|
|
if (isError($insertResult))
|
|
{
|
|
error("Error occurred while inserting Notiz: " . $insertResult->message);
|
|
return false;
|
|
}
|
|
|
|
$insertKalenderNotiz = $this->KalenderNotizModel->insert(array(
|
|
'notiz_id' => $insertResult->retval,
|
|
'eindeutige_kalender_gruppen_id' => $eindeutige_kalender_gruppen_id
|
|
));
|
|
|
|
if (isError($insertKalenderNotiz))
|
|
{
|
|
error("Error occurred while inserting KalenderNotiz: " . $insertKalenderNotiz->message);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private function updateTag($eindeutige_kalender_gruppen_id, $notizText, $lastUpdatedInOldSystem)
|
|
{
|
|
$notizType = 'hinweis';
|
|
$insertvonMockUser = 'oldToNewTempusMigration';
|
|
|
|
$this->KalenderNotizModel->addJoin('tbl_notiz', 'tbl_notiz.notiz_id = tbl_kalender_notiz.notiz_id', 'LEFT');
|
|
$this->KalenderNotizModel->db->where('tbl_notiz.typ', $notizType);
|
|
$this->KalenderNotizModel->db->where('tbl_notiz.insertvon', $insertvonMockUser);
|
|
$kalenderNotizRes = $this->KalenderNotizModel->loadWhere(array('eindeutige_kalender_gruppen_id' => $eindeutige_kalender_gruppen_id));
|
|
if (isError($kalenderNotizRes))
|
|
{
|
|
error("Error occurred while loading KalenderNotiz: " . $kalenderNotizRes->message);
|
|
return false;
|
|
}
|
|
|
|
|
|
$tag = $this->NotizModel->loadWhere(array('notiz_id' => $kalenderNotizRes->retval[0]->notiz_id));
|
|
if (isError($tag))
|
|
{
|
|
error("Error occurred while loading Notiz: " . $tag->message);
|
|
return false;
|
|
}
|
|
|
|
if (!hasData($tag))
|
|
{
|
|
error("Error occurred while loading KalenderNotiz: " . $tag->message);
|
|
return false;
|
|
}
|
|
|
|
$adjustedLastUpdatedInOldSystem = date('Y-m-d H:i:s', strtotime($lastUpdatedInOldSystem) + 5);
|
|
if ($tag->retval[0]->updateamum >= $adjustedLastUpdatedInOldSystem)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
$updateData = $this->NotizModel->update(array('notiz_id' => $tag->retval[0]->notiz_id),
|
|
array('text' => $notizText,
|
|
'updateamum' => date('Y-m-d H:i:s'),
|
|
'updatevon' => $insertvonMockUser,
|
|
'bearbeiter_uid' => null,
|
|
)
|
|
);
|
|
if (isError($updateData))
|
|
{
|
|
error("Error occurred while updating Notiz: " . $updateData->message);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|