Example #1
0
 /**
  * Erzeugt die <link> Tags für die benötigten CSS Bibliotheken
  *
  * @return string
  */
 public static function getLinkTags()
 {
     Logging::debug('Binde CSS-Bibliotheken ein: ' . count(static::$requiredLibraries) . ' / ' . count(static::$registeredLibraries));
     $result = '';
     foreach (static::$requiredLibraries as $lib) {
         if (array_key_exists($lib, static::$registeredLibraries)) {
             $filesToInclude = static::$registeredLibraries[$lib];
             foreach ($filesToInclude as $file) {
                 $result .= "\n<link href=\"{$file}\" rel=\"stylesheet\" type=\"text/css\" />";
             }
         } else {
             Logging::error('CSS-Bibliothek nicht gefunden: ' . $lib);
         }
     }
     return $result;
 }
 /**
  * Lädt das Modul mit dem übergebenen Namen
  * @param $name
  * @return Module|null
  */
 public function getModule($name)
 {
     if ($name === '') {
         Logging::warning('Leeres Modul sollte geladen werden.');
         return null;
     }
     $name = ucfirst($name);
     // Aus dem Cache holen
     $cacheId = 'module.' . $name;
     if (array_key_exists($cacheId, $this->internalCache)) {
         return $this->internalCache[$cacheId];
     }
     $result = Cache::get($cacheId, null);
     if ($result !== null) {
         $this->internalCache[$cacheId] = $result;
         return $result;
     }
     Profiler::startSection('module.load', $name);
     Logging::debug("Modul '{$name}' wird geladen");
     // Generieren der Klassendefinition für den Controller um dann via
     // Reflection die Datei und damit das Verzeichnis herauszubekommen.
     $naming = new ModuleNaming();
     $classOfController = $naming->getControllerClassFromCamelCase($name);
     if (class_exists($classOfController)) {
         $reflector = new ReflectionClass($classOfController);
         $directory = dirname($reflector->getFileName());
         $filename = $directory . '/Module.xml';
         if (file_exists($filename)) {
             $file = simplexml_load_file($filename);
             $result = $this->createByXml($file, $directory);
             unset($file);
         } else {
             Logging::error("Modul [{$name}] konnte in Pfad {$directory} nicht gefunden werden");
         }
     } else {
         Logging::warning("Controller für Modul [{$name}] konnte nicht gefunden werden [{$classOfController}]");
     }
     Cache::set($cacheId, $result);
     $this->internalCache[$cacheId] = $result;
     Profiler::endSection('module.load');
     return $result;
 }
 /**
  * @inheritdoc
  */
 public function add(HtmlOutputInterface $child, $collectionName = '')
 {
     // Das Standard-Control hat nur eine Collection. Der Parameter CollectionName
     // wird daher komplett ignoriert
     if ($child !== null) {
         $existierenderKnoten = $this->get($child->getId());
         if ($existierenderKnoten !== null) {
             if ($existierenderKnoten === $child) {
                 return $this;
             } else {
                 Logging::error("Doppelte-ID! ID: {$child->getId()} Container: {$this->getId()}");
                 return $this;
             }
         }
         if ($child->getId() !== '') {
             $this->children[$child->getId()] = $child;
         } else {
             $this->children[] = $child;
         }
     }
     return $this;
 }
 /**
  * Diese Methode erzeugt das PDO Statement und bindet die
  * Parameter gegen deren Werte. Es erfolgt tatsächlich eine Wert-
  * Bindung und keine Referenz-Bindungen! Nachträgliche Änderungen
  * der Parametervariablen haben also keinen Einfluss auf die
  * Ausführung des Statements.
  *
  * @param $sql
  * @param array $params
  */
 protected function prepareQueryAndBindParameter($sql, $params)
 {
     // Statement preparen
     try {
         $this->statement = $this->pdo->prepare($sql);
     } catch (Exception $e) {
         die('Query konnte nicht prepared werden ' . $e->getMessage() . "| {$sql}");
     }
     if ($this->statement === false) {
         Logging::error('Query konnte nicht prepared werden ' . print_r($this->pdo->errorInfo(), true));
         die('Query konnte nicht prepared werden ' . print_r($this->pdo->errorInfo(), true));
     }
     // Paramter binden
     if ($params !== null) {
         foreach ($params as $name => $value) {
             // Der Parameter-Name muss eigentlich mit : angegeben werden
             // Ist allerdings nervig, so dass wir das an dieser Stelle
             // abstrahieren.
             if ($name[0] !== ':') {
                 $name = ':' . $name;
             }
             $this->statement->bindValue($name, $value);
         }
     }
 }
 /**
  * Speichert den Datensatz ab, wenn sich der Wert des Felds geändert hat.
  *
  * @param $feld string Name des Felds, das geprüft werden soll
  * @param $wert mixed Neuer Wert
  * @return bool true, falls sich der Wert geändert hat
  */
 public function saveIfUpdated($feld, $wert)
 {
     // TODO: An der Stelle ist nicht klar, ob $wert den rohen
     // Wert oder die String-Repräsentation beinhaltet
     if (!$this->hasField($feld)) {
         Logging::error('Feld nicht gefunden ' . $feld);
         return false;
     } else {
         if ($wert != $this->felder[$feld]->getValue()) {
             $this->felder[$feld]->setValue($wert);
             $this->save();
             return true;
         }
         return false;
     }
 }
 /**
  * Erzeugt einen neuen Benutzernamen
  * @return string
  */
 protected function generateUsername()
 {
     // TODO: ACHTUNG! Diese Methode funktioniert nicht!!!
     Logging::error('generate Username liefert u.U. falsche -> doppelte Namen!!!');
     $sql = 'select count(*) anzahl from user where substr(us_vorname,1,1) = substr(:vorname,1,1) and us_nachname = :nachname';
     $this->db->query($sql, array('vorname' => $this->us_vorname, 'nachname' => $this->us_nachname));
     $row = $this->db->fetch();
     $anzahl = $row['anzahl'];
     // Falls ID > 0, dann ist der aktuelle Datensatz dabei
     // sonst dazuzählen
     if ($this->id <= 0) {
         $anzahl++;
     }
     // Benutzername
     $username = substr($this->us_vorname, 0, 1) . $this->us_nachname;
     if ($anzahl > 1) {
         $username .= $anzahl;
     }
     return $username;
 }
 /**
  * Erstellt die Unterobjekte für die einzelnen Menüs
  */
 protected function loadSubItems()
 {
     try {
         $pages = $this->page->loadChildrenForCurrentUser();
     } catch (\Exception $e) {
         Logging::error('Fehler beim Laden der Children für die Page des MenuItemControls ' . $e->getMessage());
         $pages = [];
     }
     foreach ($pages as $page) {
         $itemControl = new MenuItemControl($this, 'page' . $page->id);
         $itemControl->setPage($page);
         $itemControl->setRenderChildren($this->renderChildren);
     }
 }
 /**
  * Sendet eine Mail über den in der Konfiguration hinterlegten SMTP Account.
  * @param string $empfaenger Empfängeradresse / Wird automatisch von UTF-8 nach ANSI gewandelt
  * @param string $betreff Empfängeradresse / Wird automatisch von UTF-8 nach ANSI gewandelt
  * @param string $nachricht Nachricht als Plaintext
  * @param string $html Nachricht als HTML
  * @param string $attachment Pfad und Dateiname eines Anhangs
  * @return boolean
  */
 public function sendMail($empfaenger, $betreff, $nachricht, $html = null, $attachment = null)
 {
     if (Configuration::get('mail.from') === '') {
         Logging::warning('Kein Absender in der Konfiguration eingetragen. E-Mail wird nicht versendet');
         return false;
     }
     if ($empfaenger === '') {
         Logging::warning('Keine E-Mail Adresse übergeben');
         return false;
     }
     $empfaenger = trim($empfaenger);
     Profiler::startSection('Mailer::sendMail');
     try {
         $message = Swift_Message::newInstance();
         $message->setSubject($betreff);
         $message->setFrom(array(Configuration::get('mail.from')));
         $message->setTo(array(utf8_decode($empfaenger)));
         $message->setBody(strip_tags($nachricht));
         if ($html !== null) {
             $templatePath = Environment::get()->srcDir . '/site/mails/template.html';
             if (file_exists($templatePath)) {
                 $html = str_replace('{mail}', $html, file_get_contents($templatePath));
             }
             $message->addPart($html, 'text/html');
         }
         if ($attachment !== null) {
             $message->attach(Swift_Attachment::fromPath($attachment));
         }
         if ($this->transport === null) {
             $this->transport = Swift_SmtpTransport::newInstance(Configuration::get('mail.smtp_host'), Configuration::get('mail.smtp_port'))->setUsername(Configuration::get('mail.smtp_user'))->setPassword(Configuration::get('mail.smtp_pass'));
             $this->mailer = Swift_Mailer::newInstance($this->transport);
         }
         Logging::debug('Versende Mail per SMTP an ' . $empfaenger . ' über ' . Configuration::get('mail.smtp_host') . ':' . Configuration::get('mail.smtp_port') . ' / ' . Configuration::get('mail.smtp_user') . ' / ' . Configuration::get('mail.smtp_pass'));
         $result = $this->mailer->send($message);
         Logging::debug('Result des Mails ' . print_r($result, true));
         Profiler::endSection('Mailer::sendMail');
         return $result;
     } catch (Exception $ex) {
         Logging::error('Exception beim Senden einer Mail ' . $ex->getMessage());
         Profiler::endSection('Mailer::sendMail');
         return false;
     }
 }
 /**
  * Leitet die Ausgabe der Fehlerseite ein
  */
 protected function showError()
 {
     // Falls es zu einem Error kommt, der auch bei showError auftreten
     // würde, könnte man in eine Endlosschleife laufen. Daher nur einmal
     // ausführen
     if (!$this->error) {
         $this->error = true;
         $request = new Request();
         $request->module = 'DefaultMod';
         $request->action = 'error';
         $this->handleRequest($request);
     } else {
         Logging::error('Sende 500-Fehlermeldung. Fehler beim Darstellen des Fehlerscreens.. ');
         Http::serverError();
     }
 }
 /**
  * statische Methode, die in einem Template Variablen der Form {Var} ersetzt.
  *
  * @param BaseEntity $entity
  * @param Control $controlContainer
  * @param object[] $vars Ein Array aus Objekten. Die Objekte müssen einem Schlüssel zugeordnet sein, wie
  *                       z.B. ["schlüssel" => new Musterobjekt]. Über ein Match "{schlüssel.eigenschaft}"
  *                       kann auf das Feld 'eigenschaft' des Objekts zugegriffen werden, wenn es public ist.
  * @param string $template Wird template nicht angegeben (null) wird das zu letzt verwendete genommen
  * @param null|array $matches
  * @return string Template mit ersetzten Weren
  */
 public static function parse($entity, $controlContainer, $vars, $template, &$matches = null)
 {
     // Wenn das gleiche Template (z.B. ListView oder Grid) mehrfach ausgeführt brauchen wir
     // ja nicht den regulären Ausdruck dauernd drüber laufen lassen
     if ($matches === null && $template !== self::getInstance()->lastTemplate) {
         preg_match_all('/{([\\w\\.]*)}/', $template, $matches);
         self::getInstance()->lastTemplate = $template;
         self::getInstance()->lastMatches = $matches;
     } elseif ($matches === null) {
         $template = self::getInstance()->lastTemplate;
         $matches = self::getInstance()->lastMatches;
     }
     //in $matches[1] liegen die Group-Matches ohne geschweifte Klammern
     foreach ($matches[1] as $match) {
         $origMatch = $match;
         $useControl = false;
         if (strpos($match, '.') !== false) {
             $match = explode('.', $match);
         } else {
             if (substr($match, 0, 8) === 'control_') {
                 $useControl = true;
                 $match = substr($match, 8);
             }
         }
         $replaceWith = self::getInstance()->getReplacement($match, $entity, $controlContainer, $vars, $useControl);
         $template = str_replace("{" . $origMatch . "}", $replaceWith, $template);
     }
     // foreach
     // Ggf. enthaltenen PHP Code ausführen
     try {
         if (strpos($template, '?php') !== false) {
             ob_start();
             eval('?>' . $template);
             $template = ob_get_contents();
             ob_end_clean();
         }
     } catch (FatalErrorException $e) {
         Logging::error($e->getMessage() . ' / ' . substr($template, 0, 100));
     }
     return $template;
 }
 /**
  * @param $importId
  * @param $meldung
  */
 public static function error($importId, $meldung)
 {
     Logging::error($meldung);
     self::neuerEintrag($importId, self::LEVEL_ERROR, $meldung);
 }
 /**
  * Erstellt die Unterobjekte für die einzelnen Menüs
  */
 protected function loadMenuItems()
 {
     Profiler::startSection('SiteMenuControl.loadMenuItems');
     $this->loadRootPage();
     try {
         $pages = $this->rootPage->loadChildrenForCurrentUser();
     } catch (\Exception $e) {
         Logging::error('Fehler beim Laden der Children für die Root-Page des SiteMenuControls ' . $e->getMessage());
         $pages = [];
     }
     foreach ($pages as $page) {
         $itemControl = new MenuItemControl($this, 'page' . $page->id);
         $itemControl->setPage($page);
         $itemControl->setRenderChildren($this->renderChildren);
     }
     Profiler::endSection('SiteMenuControl.loadMenuItems');
 }
 /**
  * @param Request|array $filter
  * @param int $maxResults
  * @param int $skip
  * @return BaseEntity[]
  */
 public function filter($filter, $maxResults = -1, $skip = 0)
 {
     $result = [];
     $db = Database::getInstance();
     // Ggf. gibt es noch ein offenes Statement. Das wird jetzt gesichert und später wieder
     // hergestellt. Das ist etwas inkonsequent, weil dieser Schutz bei anderen Operationen
     // nicht besteht. Hier knallt es aber am Häufigsten, z.B. beim Eager-Loading von Navigational
     // Properties beim Iterieren durch ein anderes Ergebnis
     $oldStatement = $db->getStatement();
     $db->setStatement();
     $this->emptyClass->searchDataset($filter, false, $skip, $maxResults);
     // Jetzt nehmen wir dieses Statement aus der DB-Klasse heraus, damit das nicht aus Versehen
     // geschlossen wird.
     $statement = $db->getStatement();
     $db->setStatement();
     while ($row = $db->fetch($statement)) {
         /** @var BaseEntity $obj */
         $obj = $this->getNewInstanceOfEntity();
         $obj->loadFromRow($row);
         $result[] = $obj;
     }
     try {
         $statement->closeCursor();
     } catch (\Exception $e) {
         Logging::error($e->getMessage());
         unset($statement);
     }
     $db->setStatement($oldStatement);
     unset($statement);
     return $result;
 }