public function importDimensions($data)
{
if (is_array($data)) {
$tt_idta_variante = $data[0];
$tt_per_month = $data[2];
$tt_idta_feldfunktion = $data[4];
$new_value = $data[6];
//zuerst suchen wir den wechselknoten
$WSql = "SELECT * FROM tm_struktur WHERE idtm_stammdaten = " . $data[3];
$WechselKnoten = StrukturRecord::finder()->findBySQL($WSql);
if (is_object($WechselKnoten)) {
$sql = "SELECT idtm_struktur FROM tm_struktur WHERE idtm_stammdaten = " . $data[5] . " AND (struktur_lft BETWEEN " . $WechselKnoten->struktur_lft . " AND " . $WechselKnoten->struktur_rgt . ")";
$tt_idtm_struktur = StrukturRecord::finder()->findBySQL($sql)->idtm_struktur;
$ObjSaver = new PFBackCalculator();
$ObjSaver->setVariante($tt_idta_variante);
$ObjSaver->setStartPeriod($tt_per_month);
$ObjSaver->setStartNode($tt_idtm_struktur);
$arr_newValues[$tt_idta_feldfunktion] = $new_value;
$ObjSaver->setNewValues($arr_newValues);
$ObjSaver->run();
unset($ObjSaver);
}
unset($WechselKnoten);
}
}
public static function InitDBValues($idtm_struktur, $idta_variante, $idta_perioden = '10001')
{
//Step One, find all relevant IDs
$StartRecord = StrukturRecord::finder()->findByidtm_struktur($idtm_struktur);
if (count($StartRecord) == 1) {
$sql = "SELECT idta_struktur_type FROM tm_struktur WHERE struktur_lft BETWEEN " . $StartRecord->struktur_lft . " AND " . $StartRecord->struktur_rgt . " GROUP BY idta_struktur_type";
//here I recieve the array of values containing the elements to be changed
$GroupsToChange = StrukturRecord::finder()->findAllBySQL($sql);
foreach ($GroupsToChange as $Group) {
$checker = FeldfunktionRecord::finder()->count("idta_struktur_type = ?", $Group->idta_struktur_type);
if ($checker > 0) {
$sqlElemente = "SELECT idtm_struktur,idta_struktur_type FROM tm_struktur WHERE (struktur_lft BETWEEN " . $StartRecord->struktur_lft . " AND " . $StartRecord->struktur_rgt . ") AND idta_struktur_type=" . $Group->idta_struktur_type;
$ElementsToChange = StrukturRecord::finder()->findAllBySQL($sqlElemente);
foreach ($ElementsToChange as $Element) {
echo $Element->idtm_struktur;
$ObjSaver = new PFBackCalculator();
$ObjSaver->setStartPeriod($idta_perioden);
$ObjSaver->setVariante($idta_variante);
$ObjSaver->setStartNode($Element->idtm_struktur);
$ObjSaver->build_DIMKEY($Element->idtm_struktur);
$ObjSaver->initTTWerte($Element->idtm_struktur, $Element->idta_struktur_type);
unset($ObjSaver);
}
empty($checker);
}
}
unset($ElementsToChange);
}
}
public function updateDBValue($sender, $param)
{
$MaskField = CustomMaskFieldRecord::finder()->find("cuf_maskenname = ? AND cuf_maskenid = ?", $this->cuf_maskenname->Text, $sender->parent->Id);
//als erstes lese ich die Periode aus
$Periode = PeriodenRecord::finder()->findByidta_perioden($MaskField->idta_perioden);
$w_monat = $Periode->per_intern;
$w_jahr = $this->getYearByMonth($w_monat);
//auslesen des roots, damit ich den linken und den rechten wert habe...
$parent_idtm_struktur = StrukturRecord::finder()->findByidtm_struktur($this->idtm_struktur->Text);
//jetzt suche ich die entsprechende dimension innerhalb der selektion
$idtm_struktur = StrukturRecord::finder()->find('(struktur_lft BETWEEN ? AND ?) AND idtm_stammdaten = ?', $parent_idtm_struktur->struktur_lft, $parent_idtm_struktur->struktur_rgt, $MaskField->idtm_stammdaten)->idtm_struktur;
//hier startet jetzt der Part, wo ich nur eine Periode habe -> entweder SubJahr oder Jahr...
$PFBackCalculator = new PFBackCalculator();
$PFBackCalculator->setVariante($MaskField->idta_variante);
/* Folgende Parameter sind zur Berechnung der Werte notwendig...
* @param idta_periode -> die interne Periodenbezeichnung -> 10001 für 1. Jahr oder 1 für 1 Monat (Bsp)
* @param idtm_struktur -> die Struktur ID, auf der die Werte nachher gespreichert werden sollen
* @param w_dimkey -> der Schlüssel, der angehängt werden soll...
* @param assoc_array(feldbezug=>wert) -> array mit den Werten, die als "neu" betrachtet werden sollen...
*/
$PFBackCalculator->setStartPeriod($w_monat);
$PFBackCalculator->setStartNode($idtm_struktur);
//vorbereiten des Wertearrays, damit die bestehenden Werte in der Datenbank, mit den neuen Uerberschrieben werden koennen
//jetzt laden wir die einzelnen Werte
$NEWWerteRecord = WerteRecord::finder()->findBySql("SELECT w_wert FROM tt_werte WHERE idtm_struktur = '" . $idtm_struktur . "' AND idta_feldfunktion = '" . $MaskField->idta_feldfunktion . "' AND w_jahr = '" . $w_jahr . "' AND w_monat = '" . $w_monat . "' AND w_id_variante = '" . $MaskField->idta_variante . "' LIMIT 1");
$w_wert[$MaskField->idta_feldfunktion] = $this->cleanInputValue($sender->Text, $MaskField, 1);
$PFBackCalculator->setNewValues($w_wert);
$PFBackCalculator->run();
}
public function saveStrukturBericht($sender, $param)
{
$mySession = "";
$mySession = UserFelderRecord::finder()->findAllBy_user_id($this->User->getUserId($this->User->Name));
foreach ($mySession as $myFieldRecord) {
$arr_newValues = array();
//very important!!! otherwise we have values which dont exist
$arr_MyFields = array();
$uniqueID = $myFieldRecord->tuf_feldname;
//lets start the saving
//$UniqueID = 'xxx'.$inp_per_year.'xxx'.$inp_per_month.'xxx'.$inp_idta_struktur_type.'xxx'.$inp_idta_feldfunktion.'xxx'.$inp_idtm_struktur.'xxx'.$inp_idta_variante.'xxx';
//$SaveString = $jahr."xxx".$monat."xxx".$local_ff."xxx".$local_id; definition of the string to pass
$arr_MyFields = preg_split("/xxx/", $uniqueID);
$tt_per_year = $arr_MyFields[1];
$tt_per_month = $arr_MyFields[2];
$tt_idta_struktur_type = $arr_MyFields[3];
$tt_idta_feldfunktion = $arr_MyFields[4];
$tt_idtm_struktur = $arr_MyFields[5];
$tt_idta_variante = $arr_MyFields[6];
//abrufen des aktuellen DB-Wertes
$ExistingValue = WerteRecord::finder()->findBySql("SELECT w_wert FROM tt_werte WHERE idtm_struktur = '" . $tt_idtm_struktur . "' AND idta_feldfunktion = '" . $tt_idta_feldfunktion . "' AND w_jahr = '" . $tt_per_year . "' AND w_monat = '" . $tt_per_month . "' AND w_id_variante = '" . $tt_idta_variante . "' LIMIT 1");
//formatieren, damit es mit dem inhalt aus der zelle vergleichbar wird
//CHECKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK
if (is_Object($ExistingValue)) {
$CompareValue = number_format($ExistingValue->w_wert, 2, '.', '');
} else {
$CompareValue = "0.00";
}
//here I start the magic server calculation;)
if ($CompareValue === $this->page->ACTPanel->FindControl($uniqueID)->Text) {
} else {
$ObjSaver = new PFBackCalculator();
$ObjSaver->setVariante($tt_idta_variante);
$ObjSaver->setStartPeriod($tt_per_month);
$ObjSaver->setStartNode($tt_idtm_struktur);
//$SaveString = $tt_per_year."xxx".$tt_per_month."xxx".$tt_idta_feldfunktion."xxx".$tt_idtm_struktur;
//$NEWWerteRecord = WerteRecord::finder()->findBySql("SELECT * FROM tt_werte WHERE idtm_struktur = '".$tt_idtm_struktur."' AND idta_feldfunktion = '".$tt_idta_feldfunktion."' AND w_jahr = '".$tt_per_year."' AND w_monat = '".$tt_per_month."' AND w_id_variante = '".$tt_idta_variante."' LIMIT 1");
$arr_newValues[$tt_idta_feldfunktion] = $this->page->ACTPanel->FindControl($uniqueID)->Text;
$ObjSaver->setNewValues($arr_newValues);
$ObjSaver->run();
unset($ObjSaver);
}
}
$sender->Text = "Saved";
}
public function saveValues()
{
//if(count(WorkflowRecord::finder()->find("wfl_modul='idtm_struktur' AND wfl_id=? AND wfl_status=?",$this->STRcurrentID,$this->wfl_status->Text))==0){
$WFRecord = new WorkflowRecord();
$WFRecord->wfl_modul = "idtm_struktur";
$WFRecord->wfl_id = $this->STRcurrentID;
$WFRecord->wfl_status = $this->wfl_status->Text;
$WFRecord->idtm_user = $this->User->GetUserId($this->User->Name);
$WFRecord->idta_variante = $this->GLOBALVARIANTE;
$WFRecord->idta_periode = $this->Periode;
$WFRecord->save();
//}
$myDimKey = $this->build_DIMKEY($this->STRcurrentID);
if ($this->SinglePeriode == 0 and count($this->Perioden) > 1) {
$this->SaveButton->Text = "saved";
$jahr = 0;
$monat = 0;
//hier werden jetzt die einzelnen Werte geladen
foreach ($this->Perioden as $key => $value) {
if (preg_match('/^\\d\\d\\d\\d/', $value)) {
$jahr = $key;
$monat = $key;
} else {
$jahr = $this->getYearByMonth($key);
$monat = $key;
}
//jetzt laden wir die einzelnen Werte
foreach ($this->FunktionsFelder as $funkID) {
$myUniquID = "RLIQ" . 'XXX' . $jahr . 'XXX' . $monat . 'XXX' . $this->piq_idta_struktur_type . 'XXX' . $funkID . 'XXX' . $this->STRcurrentID;
$NEWWerteRecord = WerteRecord::finder()->findBySql("SELECT * FROM tt_werte WHERE idtm_struktur = '" . $this->STRcurrentID . "' AND idta_feldfunktion = '" . $funkID . "' AND w_jahr = '" . $jahr . "' AND w_monat = '" . $monat . "' AND w_id_variante = '" . $this->GLOBALVARIANTE . "' LIMIT 1");
$NEWWerteRecord->w_wert = $this->page->ACTPanel->FindControl($myUniquID)->Text;
$NEWWerteRecord->w_id_variante = $this->GLOBALVARIANTE;
$NEWWerteRecord->w_dimkey = $myDimKey;
$NEWWerteRecord->save();
}
}
foreach ($this->Perioden as $key => $value) {
if (preg_match('/^\\d\\d\\d\\d/', $value)) {
//echo "Hier startet der Backcalculator";
$myRunner = new PFBackCalculator();
$myRunner->setVariante($this->GLOBALVARIANTE);
$myRunner->runStructureCollector($this->STRcurrentID, $key, $this->GLOBALVARIANTE);
}
}
} else {
foreach ($this->Perioden as $key => $value) {
//hier laden wir die variablen, die wir benoetigen um die letzten Werte auszulesen
if (preg_match('/^\\d\\d\\d\\d/', $value)) {
$jahr = $key;
$monat = $key;
} else {
$jahr = $this->getYearByMonth($key);
$monat = $key;
}
//hier startet jetzt der Part, wo ich nur eine Periode habe -> entweder SubJahr oder Jahr...
$PFBackCalculator = new PFBackCalculator();
/* Folgende Parameter sind zur Berechnung der Werte notwendig...
* @param idta_periode -> die interne Periodenbezeichnung -> 10001 für 1. Jahr oder 1 für 1 Monat (Bsp)
* @param idtm_struktur -> die Struktur ID, auf der die Werte nachher gespreichert werden sollen
* @param w_dimkey -> der Schlüssel, der angehängt werden soll...
* @param assoc_array(feldbezug=>wert) -> array mit den Werten, die als "neu" betrachtet werden sollen...
*/
$PFBackCalculator->setStartPeriod($monat);
$PFBackCalculator->setStartNode($this->STRcurrentID);
//vorbereiten des Wertearrays, damit die bestehenden Werte in der Datenbank, mit den neuen Uerberschrieben werden koennen
//jetzt laden wir die einzelnen Werte
foreach ($this->FunktionsFelder as $funkID) {
$myUniquID = "RLIQ" . 'XXX' . $jahr . 'XXX' . $monat . 'XXX' . $this->piq_idta_struktur_type . 'XXX' . $funkID . 'XXX' . $this->STRcurrentID;
$NEWWerteRecord = WerteRecord::finder()->findBySql("SELECT * FROM tt_werte WHERE idtm_struktur = '" . $this->STRcurrentID . "' AND idta_feldfunktion = '" . $funkID . "' AND w_jahr = '" . $jahr . "' AND w_monat = '" . $monat . "' AND w_id_variante = '" . $this->GLOBALVARIANTE . "' LIMIT 1");
if ($NEWWerteRecord->w_wert != $this->page->ACTPanel->FindControl($myUniquID)->Text) {
$w_wert[$funkID] = $this->page->ACTPanel->FindControl($myUniquID)->Text;
}
}
$PFBackCalculator->setNewValues($w_wert);
$PFBackCalculator->setVariante($this->GLOBALVARIANTE);
$PFBackCalculator->run();
$this->SaveButton->Text = "saved";
}
}
}
private function calc_splasher($local_ff, $local_monat, $local_jahr, $local_id, $newValue)
{
//die eingabe erfolgt auf monatsebene
//Holen der Stammdateninfo
$StrukturWechselKnoten = StrukturRecord::finder()->findByPK($local_id);
$StammdatenID = $StrukturWechselKnoten->idtm_stammdaten;
//Ermitteln des Gesamtwertes der entsprechenden Verteilung
$sql = "SELECT spl_monat, sum(spl_faktor) AS spl_faktor FROM tt_splasher WHERE idta_variante = '" . $this->GLOBALVARIANTE . "' AND idtm_stammdaten='" . $StammdatenID . "' AND spl_monat='" . $local_monat . "'";
$Gesamtwert = TTSplasherRecord::finder()->findBySql($sql)->spl_faktor;
//Ermitteln der Faktoren für die Verteilung, dabei holen wir auch die Zieldimension
$sql = "SELECT to_idtm_stammdaten,spl_monat,idta_feldfunktion, sum(spl_faktor) AS spl_faktor FROM tt_splasher WHERE idta_variante = " . $this->GLOBALVARIANTE . " AND idtm_stammdaten=" . $StammdatenID . " AND spl_monat=" . $local_monat . " GROUP BY to_idtm_stammdaten,spl_monat,idta_feldfunktion";
$Einzelwerte = TTSplasherRecord::finder()->findAllBySql($sql);
//wenn wir einen treffer haben, koennen wir nach der standardverteilung arbeiten
if (is_array($Einzelwerte) and $Gesamtwert != 0) {
foreach ($Einzelwerte as $Einzelwert) {
$sql = "SELECT idtm_struktur FROM tm_struktur WHERE idtm_stammdaten = '" . $Einzelwert->to_idtm_stammdaten . "'";
$sql .= " AND (struktur_lft BETWEEN " . $StrukturWechselKnoten->struktur_lft . " AND " . $StrukturWechselKnoten->struktur_rgt . ")";
$UpdateStrukturId = StrukturRecord::finder()->findBySQL($sql)->idtm_struktur;
$Einzelfaktor = $Einzelwert->spl_faktor;
$td_startvalue = $Einzelfaktor / $Gesamtwert * $newValue;
//hier startet jetzt der Part, wo ich nur eine Periode habe -> entweder SubJahr oder Jahr...
$PFBackCalculator = new PFBackCalculator();
/* Folgende Parameter sind zur Berechnung der Werte notwendig...
* @param idta_periode -> die interne Periodenbezeichnung -> 10001 für 1. Jahr oder 1 für 1 Monat (Bsp)
* @param idtm_struktur -> die Struktur ID, auf der die Werte nachher gespreichert werden sollen
* @param w_dimkey -> der Schlüssel, der angehängt werden soll...
* @param assoc_array(feldbezug=>wert) -> array mit den Werten, die als "neu" betrachtet werden sollen...
*/
$PFBackCalculator->setStartPeriod($Einzelwert->spl_monat);
$PFBackCalculator->setStartNode($UpdateStrukturId);
//vorbereiten des Wertearrays, damit die bestehenden Werte in der Datenbank, mit den neuen Uerberschrieben werden koennen
//jetzt laden wir die einzelnen Werte
$w_wert[$Einzelwert->idta_feldfunktion] = $td_startvalue;
$PFBackCalculator->setNewValues($w_wert);
$PFBackCalculator->setVariante($this->GLOBALVARIANTE);
$PFBackCalculator->run();
unset($PFBackCalculator);
unset($UpdateStrukturId);
}
} else {
unset($EinzelWerte);
//zuerst muss ich die Anzahl der Knoten ermitteln, die in der Zieldimensionsgruppe vorhanden sind...
$idta_stammdaten_group = StammdatenRecord::finder()->findByPK($StammdatenID)->idta_stammdaten_group;
$SplasherInfo = SplasherRecord::finder()->find('from_idta_stammdaten_group = ? AND from_idta_feldfunktion = ?', $idta_stammdaten_group, $local_ff);
$to_idta_stammdaten_group = $SplasherInfo->to_idta_stammdaten_group;
$to_idta_feldfunktion = $SplasherInfo->to_idta_feldfunktion;
//hier ermitteln wir die anzahl der zielwerte
$AnzahlZielWerte = StammdatenRecord::finder()->count('idta_stammdaten_group = ?', $to_idta_stammdaten_group);
$sql = "SELECT idtm_stammdaten FROM tm_stammdaten WHERE idta_stammdaten_group = '" . $to_idta_stammdaten_group . "'";
$Einzelwerte = StammdatenRecord::finder()->findAllBySql($sql);
if (is_array($Einzelwerte)) {
foreach ($Einzelwerte as $Einzelwert) {
$sql = "SELECT idtm_struktur FROM tm_struktur WHERE idtm_stammdaten = '" . $Einzelwert->idtm_stammdaten . "'";
$sql .= " AND (struktur_lft BETWEEN " . $StrukturWechselKnoten->struktur_lft . " AND " . $StrukturWechselKnoten->struktur_rgt . ")";
$UpdateStrukturId = StrukturRecord::finder()->findBySQL($sql)->idtm_struktur;
$Einzelfaktor = 1 / $AnzahlZielWerte;
$td_startvalue = $Einzelfaktor * $newValue;
//hier startet jetzt der Part, wo ich nur eine Periode habe -> entweder SubJahr oder Jahr...
$PFBackCalculator = new PFBackCalculator();
/* Folgende Parameter sind zur Berechnung der Werte notwendig...
* @param idta_periode -> die interne Periodenbezeichnung -> 10001 für 1. Jahr oder 1 für 1 Monat (Bsp)
* @param idtm_struktur -> die Struktur ID, auf der die Werte nachher gespreichert werden sollen
* @param w_dimkey -> der Schlüssel, der angehängt werden soll...
* @param assoc_array(feldbezug=>wert) -> array mit den Werten, die als "neu" betrachtet werden sollen...
*/
$PFBackCalculator->setStartPeriod($local_monat);
$PFBackCalculator->setStartNode($UpdateStrukturId);
//vorbereiten des Wertearrays, damit die bestehenden Werte in der Datenbank, mit den neuen Uerberschrieben werden koennen
//jetzt laden wir die einzelnen Werte
$w_wert[$to_idta_feldfunktion] = $td_startvalue;
$PFBackCalculator->setNewValues($w_wert);
$PFBackCalculator->setVariante($this->GLOBALVARIANTE);
$PFBackCalculator->run();
unset($PFBackCalculator);
unset($UpdateStrukturId);
}
}
}
}