Archivo Explosivo: PHP-Frameworks

Robo – Modern Taskrunner for PHP

Eine PHP-Variante von Gulp und Grunt für PHP:

Robo is a task runner you always have been looking for. It allows you to write fully customizable tasks in common OOP PHP style. Robo has comprehensive list of built-in common tasks for development, testing, and deployment.

robo.li

Archivo Explosivo: PHP-Frameworks

Constructr CMS 3.0

ConstructrCMS (https://github.com/phaziz/ConstructrCMS-3) based on FatFree-Framework, Materialize CSS, MySQL/PDO, jQuery/Javascript and Passion!

That’s it for now (Version 3.0 / 2015-07-29):

– Page-Management
– Create, edit, re-order/order, activate/deactivate and delete Pages
– Page specific CSS- and JS-Content
– Markdown Content-Management with Live-Preview
– Create, edit, re-order/order, activate/deavtivate and delete Content-Elements
– Template-Management
– EASY PHP-Templates
– Asset-Management (Uploads) with Live-Preview
– Add, edit, delete, Uploads
– User Management
– Create, edit, delete User-Accounts
– User Rights-Management
– Activate/Deactivate UserRight
– User Password resetting

INSTALLATION:
– VISIT THE INSTALLER AT http://yourdomain.tld/CONSTRUCTR-CMS-SETUP/

CHANGELOG
– 2015-07-29 AutoInsert Markdown for Files / little Bugfixes and minor Features
– 2015-07-28 Webinstaller / little Bugfixes and minor Features
– 2015-07-23 Grande Update IV…
– 2015-03-23 Grande Update III…
– 2015-03-21 Grande Update II…
– 2015-03-19 Grande Update…
– 2015-03-18 Initial commit

Archivo Explosivo: PHP-Frameworks

Slim 3 – Sekelton App gefunden

Ein simples Skelett bestehend aus Slim3, Twig und Monolog: GitHub

Archivo Explosivo: PHP-Frameworks
ConstructrCMS 2.0

Constructr CMS 2.0

Bald ist es soweit – Constructr CMS Version 2.0 auf Basis eines neuen PHP-Frameworks (FatFree)…

weiterlesen >

Archivo Explosivo: PHP-Frameworks

Constructr CMS V. 1.04.3

Constructr CMS
ConstructrCMS (http://constructr-cms.org) based on Slim-PHP5-Framework, Twitter Bootstrap, MySQL/PDO, jQuery/Javascript and Passion!

That’s it for now (Version 1.04.3 / 2015-02-11):

– C.R.U.D. Pages
– Page specific CSS- and JS-Content
– Automatic sitemap.xml generation
– C.R.U.D. Content-Elements
– Content Trashcan and Recovery
– C.R.U.D. Uploads
– Media information (Title, Copyright, Description, Keywords)
– Media Trashcan and Recovery
– 2 Factor Authentication-Login (2FA)
– User Management
– User Rights-Management
– User Password resetting via CONSTRUCTR_CONF-Option for all User-Accounts
– Generating dynamic Websites
– Generating Domain specific static Websites
– FTP-Transfer of static Sites to Frontend-Domain
– Backend Searchengine
– Constructr-Postmaster for Contact-Form-Handling in Frontend
– File based Website-Caching
– Easy Plugin-System (beta feature)
CHANGELOG

– 2015-02-11
– New Feature: Page specific CSS/JS-Content
– Bugfixes
– CleanUp
– Assets Updates

Archivo Explosivo: PHP-Frameworks
PHP PDO

PDO in Slim

Schreibt doch keiner mehr pures MySQL mit den entsprechenden PHP-Funktionen… Deshalb eine Anbindung im PHP PDO Style in Slim:

In der index.php im Root-Level wird PDO eingebunden und instanziert:



    $HOSTNAME = "DATENBANK_HOST";
    $DATABASE = "DATENBANK";
    $USERNAME = "BENUTZERNAME";
    $PASSWORD = "PASSWORD";

    try
    {
        $DBCON = new PDO("mysql:host=" . $HOSTNAME . ";dbname=" . $DATABASE,$USERNAME,$PASSWORD,
            array
            (
                PDO::ATTR_PERSISTENT => true
            )
        );

        $DBCON -> setAttribute(PDO::ATTR_ERRMODE,PDO::ERRMODE_EXCEPTION);
    }
    catch (PDOException $e)
    {
        die();
    }

Danach kann PDO in den gewünschten Routen benutzt werden:


    ...
    try {
        $ORDERS = $DBCON -> prepare('SELECT * FROM ...;');
        $ORDERS -> execute();
    } catch (PDOException $e) {
        echo $e -> getMessage();
        die();
    }
Archivo Explosivo: PHP-Frameworks
Idiorm & Paris

Slim Framework und Datenbanken

Wie wahrscheinlich bei jedem andern Framework, gibt es auch bei Slim mehrere Möglichkeiten eine Datenbankanbindung herzustellen.

Natives SQL, Anbindung per PDO, oder eine Anbindung durch ein ORM der Wahl. Wenn es um ORMs geht, kann ich nur eine Empfehlung für die Kombination Idiorm & Paris von Jamie Matthews aussprechen. Wobei Idiorm die Rolle des objekt-relationalen-Mapping’s und Query-Builder’s übernimmt und Paris das „Active Record“-Pattern implementiert. Beide sehr klein und äußerst flink ;-)

Um dieses dynamische Duo mit Slim zu verbinden, müssen die entsprechenden Dateien von Paris & Idiorm heruntergeladen werden und in der Verzeichnisstruktur des Projekts abgelegt werden. In der Index-Datei des Projekts können diese Klassen dann inkludiert und konfiguriert werden:


    ...
    require 'Helper/idiorm.php';
    require 'Helper/paris.php';
    ...

    ORM::configure('mysql:host=MEIN_DATENBANK_HOST;dbname=MEINE_DATENBANK');
    ORM::configure('username','BENUTZERNAME');
    ORM::configure('password','PASSSWORT');
    ORM::configure('logging','false');

    // Primärschlüssel der eingebundenen Tabellen definieren
    ORM::configure('id_column_overrides', array
        (
            'logs' => 'lg_id',
            'tabelle2' => 'primary_id2',
            ...
        )
    );
    ...

Wenn dies ohne Fehlermeldungen im Browser abgeschlossen ist, kann man das Duo in den gewünschten Routen verwenden und seine Abfragen damit gestalten:


    ...
    $LOG = Model::factory('Logs')->create();
    if($LOG instanceof Logs){
        $LOG -> log_timestamp = date('Y-m-d H:i:s');
        $LOG -> log_user_id = $_USERID;
        $LOG -> log_username = $_USERNAME;
        $LOG -> log_txt = 'Logging...';
        $LOG->save();
    }
    ...

Paris und Idiorm auf GitHub.

Archivo Explosivo: PHP-Frameworks
Slim PHP-Micro-Framework

$_GET und $_POST-Parameter in Slim

Wie bringe ich Slim dazu, $_GET-/$_POST-Parameter zu erhalten?

Nehmen wir an, in unserer Anwendung gibt es eine Ansicht http://domain.tld/formular. Hier gibt es ein kleines Kontaktformular mit den Feldern Name, eMail-Adresse und Nachricht.



Dieses Formular kann ich per Formular-Action an die URL http://domain.tld/formular-verarbeiten senden. Die Formular Methode GET :



    $app -> get('/formular-verarbeiten', function () use ($app)
    ...

Die entsprechende Ansicht in der POST-Variante:



    $app -> post('/formular-verarbeiten', function () use ($app)
    ...

Hier werden noch keine Formular-Werte übergeben, verarbeitet, oder zugewiesen... das erledigen wir nun innerhalb der Route formular-verarbeiten



    $app -> get/post('/formular-verarbeiten', function () use ($app)
        {
            //GET variable
            $GET_NAME = $app -> request -> get('name');

            //POST variable
            $POST_NAME = $app -> request -> post('name');
            ...
        }
    );

Ab den Zeilen $GET_NAME/$POST_NAME = $app -> request -> get/post('name');, steht mir die Variable $GET_NAME/$POST_NAME mit dem aus dem Formular übergebenem Wert zur Verfügung.

Archivo Explosivo: PHP-Frameworks
Slim PHP-Micro-Framework

Parameter-Übergabe mit Slim

Das absolut Wichtigste in einer programmierten Anwendung ist häufig die Fragestellung: „Wie komme ich an meine Variablen?“

In Slim, wie auch in vielen anderen PHP-Frameworks, kann ich schon bei Aufruf der Route einer Variablen einen Wert zuweisen:



    $app -> get('/hello/:name', function ($name) use ($app)
        {
            echo 'Hello ' . $name . '!';
        }
    );

Mit der Route „/hello/:name“ bereite ich Slim darauf vor, das diese Route aus einem statischen Teil (/hello) und einem variablen Teil (/:name) besteht. Der Wert, der als „:name“ übergeben wird, wird der Variablen „$name“ zugewiesen. In der Ausgabe dieser Route, kann ich diese Variable direkt weiter verarbeiten… zum Beispiel einfach ausgeben: echo ‚Hello ‚ . $name . ‚!‘;

Rufe ich im Browser meine Route auf und übergebe meinen Namen als Variable :name/$name (http://www.domain.tld/hello/Christian), erhalte ich die folgende Ausgabe:

Hello Christian!

Einfacher geht es kaum, oder?

Bin ich mir nicht sicher, ob ich in meiner Anwendung eine Variable auch wirklich bekomme, kann ich diese in der Routen-Definition einfach in Klammern schreiben. Das zeigt Slim: Es könnte dieser Variablen ein Wert zugewiesen werden, dies ist aber nicht zwingend notwendig und bringt meine Anwendung nicht gleich komplett zum Abbruch mit lauter PHP-Fehlermeldungen:



    $app -> get('/hello(/:name)', function ($name = '') use ($app)
        {
            if($name == '')
            {
                echo 'Hello!';
            }
            else
            {
                echo 'Hello ' . $name . '!';
            }
        }
    );

Jetzt kann ich meine Anwendung über zwei URLs im Browser aufrufen:

  • http://www.domain.tld/hello/Christian
  • http://www.domain.tld/hello

Bei Aufruf No. 1 mit meinem Namen als Wert für die Variable :name/$name erhalte ich die gewohnte Ausgabe „Hello Christian!“. Bei Aufruf No. 2 erhalte ich lediglich die Ausgabe „Hello!“, eben weil der Variablen in diesem Fall kein Wert zugewiesen wurde und der vordefinierte Wert zugewiesen wird.

Hier gibt es eine kleine Demo-Installation

Archivo Explosivo: PHP-Frameworks
Slim PHP-Micro-Framework

Slim micro PHP-Framework

Ich kann nur bestätigen, was einem als erstes auf der Internetseite von Slim ins Auge fällt: „Slim is a PHP micro framework that helps you quickly write simple yet powerful web applications and APIs.“.

Klein, übersichtlich, einfach in der Handhabung und in Benchmarks immer unter den schnellsten Frameworks. Einige der Vorteile sind:

  • Eine ordentliche Dokumentation
  • Composer Unterstützung
  • Ein mächtiger Router für saubere URLs im Browser
  • Unterstützung aller Standard HTTP-Methoden (GET, POST, PUT, …)
  • Parametern in URLs über Konditionen , oder sogar Wildcards
  • Beeinflussung des Programmablaufs während der Ausführung (Umleitungen, Weiterleitungen, Stop, …)
  • „Middleware“ für Erweiterung der Grundfunktionalität (Templates, Logging, …)
  • Benachrichtigungssystem (Flash-Messages)Unterstützung für sichere Cookies (AES 256)
  • HTTP-Caching über eTag-Parameter (einfach erweiterbar über ein statischen Document-Cache)
  • Fehlerbehandlung mit Debug-Informationen
  • Einfachste Konfiguration
  • Keine besonderen Ansprüche an die Hosting-Umgebung (PHP Version >= 5.3.0, mcrypt-Extensionfür sichere Cookies)

Da hat Josh Lockhart ein ordentliches Framework auf die Beine gestellt.

Eine einfache „Hello World“-Anwendung mit Slim kann so einfach aussehen:



    require 'Slim/Slim.php';
    \Slim\Slim::registerAutoloader();

    $app = new \Slim\Slim();

    $app->get('/', function () use ($app)
        {
            echo "Hello World";
        }
    );

    $app -> run();


Slim wird inkludiert, eine Instanz wird gebildet, eine Anweisung für die Route/URL ‚/‘ erstellt (http://domain.tld) und schließlich wird die Slim-Applikation gestartet und ausgeführt.

Micro-Framework VS. Fullstack… Was bedeutet Micro? Eignet sich Slim auch für größere Projekte? Ich gebe ein klares „Jo“ von mir.

Mein eigenes Content Mangement System ConstructrCMS basiert auf Slim. Viele Jahre setze ich bei privaten Vergnügen, aber auch bei geschäftskritischen Anwendungen auf Slim als Unterbau. An die Grenzen gestoßen bin ich damit noch nie. Alles eine Frage der Organisation.

Wird zum Beispiel ein ORM benötigt, inkludiere ich das gewünschte System. Wird in einer speziellen Route eine Erweiterung benötigt, kann ich diese global instanzieren und bei Bedarf an Slim übergeben, oder nur in der speziellen Route einbinden. Routen, Templates und Models können in Unterverzeichnissen ausgelagert werden – die Übersicht leidet dadurch auch bei großen Anwendungen nicht.

Ich kann Slim jedem nur wärmstens empfehlen – es muss nicht immer ein Symphony, Yii oder Zend sein!

Hiermit startet meine kleine Beitragsreihe über das Slim-PHP-Framework.