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);
     }
 }
示例#2
0
 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);
     }
 }
示例#3
0
 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";
 }
示例#5
0
 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);
             }
         }
     }
 }