first commit

code/web/backend/application/core/Application.php

@@ -0,0 +1,100 @@
+<?php
+
+/**
+ * Class Application
+ * The heart of the application
+ */
+class Application
+{
+    /** @var mixed Instance of the controller */
+    private $controller;
+
+    /** @var array URL parameters, will be passed to used controller-method */
+    private $parameters = array();
+
+    /** @var string Just the name of the controller, useful for checks inside the view ("where am I ?") */
+    private $controller_name;
+
+    /** @var string Just the name of the controller's method, useful for checks inside the view ("where am I ?") */
+    private $action_name;
+
+    /**
+     * Start the application, analyze URL elements, call according controller/method or relocate to fallback location
+     */
+    public function __construct()
+    {
+        // create array with URL parts in $url
+        $this->splitUrl();
+
+	    // creates controller and action names (from URL input)
+	    $this->createControllerAndActionNames();
+
+        // does such a controller exist ?
+        if (file_exists(Config::get('PATH_CONTROLLER') . $this->controller_name . '.php')) {
+
+            // load this file and create this controller
+            // example: if controller would be "car", then this line would translate into: $this->car = new car();
+            require Config::get('PATH_CONTROLLER') . $this->controller_name . '.php';
+            $this->controller = new $this->controller_name();
+
+            // check for method: does such a method exist in the controller ?
+            if (method_exists($this->controller, $this->action_name)) {
+                if (!empty($this->parameters)) {
+                    // call the method and pass arguments to it
+                    call_user_func_array(array($this->controller, $this->action_name), $this->parameters);
+                } else {
+                    // if no parameters are given, just call the method without parameters, like $this->index->index();
+                    $this->controller->{$this->action_name}();
+                }
+            } else {
+                header('location: ' . Config::get('URL') . 'error');
+            }
+        } else {
+            header('location: ' . Config::get('URL') . 'error');
+        }
+    }
+
+    /**
+     * Get and split the URL
+     */
+    private function splitUrl()
+    {
+        if (Request::get('url')) {
+
+            // split URL
+            $url = trim(Request::get('url'), '/');
+            $url = filter_var($url, FILTER_SANITIZE_URL);
+            $url = explode('/', $url);
+
+            // put URL parts into according properties
+            $this->controller_name = isset($url[0]) ? $url[0] : null;
+            $this->action_name = isset($url[1]) ? $url[1] : null;
+
+            // remove controller name and action name from the split URL
+            unset($url[0], $url[1]);
+
+            // rebase array keys and store the URL parameters
+            $this->parameters = array_values($url);
+        }
+    }
+
+	/**
+	 * Checks if controller and action names are given. If not, default values are put into the properties.
+	 * Also renames controller to usable name.
+	 */
+	private function createControllerAndActionNames()
+	{
+		// check for controller: no controller given ? then make controller = default controller (from config)
+		if (!$this->controller_name) {
+			$this->controller_name = Config::get('DEFAULT_CONTROLLER');
+		}
+
+		// check for action: no action given ? then make action = default action (from config)
+		if (!$this->action_name OR (strlen($this->action_name) == 0)) {
+			$this->action_name = Config::get('DEFAULT_ACTION');
+		}
+
+		// rename controller name to real controller class/file name ("index" to "IndexController")
+		$this->controller_name = ucwords($this->controller_name) . 'Controller';
+	}
+}

code/web/backend/application/core/Auth.php

@@ -0,0 +1,28 @@
+<?php
+
+/**
+ * Class Auth
+ * Checks if user is logged in, if not then sends the user to "yourdomain.com/login".
+ * Auth::checkAuthentication() can be used in the constructor of a controller (to make the
+ * entire controller only visible for logged-in users) or inside a controller-method to make only this part of the
+ * application available for logged-in users.
+ */
+class Auth
+{
+    public static function checkAuthentication()
+    {
+        // initialize the session (if not initialized yet)
+        Session::init();
+
+        // if user is not logged in...
+        if (!Session::userIsLoggedIn()) {
+            // ... then treat user as "not logged in", destroy session, redirect to login page
+            Session::destroy();
+            header('location: ' . Config::get('URL') . 'login');
+            // to prevent fetching views via cURL (which "ignores" the header-redirect above) we leave the application
+            // the hard way, via exit(). @see https://github.com/panique/php-login/issues/453
+            // this is not optimal and will be fixed in future releases
+            exit();
+        }
+    }
+}

code/web/backend/application/core/Config.php

@@ -0,0 +1,23 @@
+<?php
+
+class Config
+{
+	// this is public to allow better Unit Testing
+    public static $config;
+
+    public static function get($key)
+    {
+        if (!self::$config) {
+
+	        $config_file = '../application/config/config.' . Environment::get() . '.php';
+
+			if (!file_exists($config_file)) {
+				return false;
+			}
+
+	        self::$config = require $config_file;
+        }
+
+        return self::$config[$key];
+    }
+}

code/web/backend/application/core/Controller.php

@@ -0,0 +1,31 @@
+<?php
+
+/**
+ * This is the "base controller class". All other "real" controllers extend this class.
+ * Whenever a controller is created, we also
+ * 1. initialize a session
+ * 2. check if the user is not logged in anymore (session timeout) but has a cookie
+ */
+class Controller
+{
+    /** @var View View The view object */
+    public $View;
+
+    /**
+     * Construct the (base) controller. This happens when a real controller is constructed, like in
+     * the constructor of IndexController when it says: parent::__construct();
+     */
+    function __construct()
+    {
+        // always initialize a session
+        Session::init();
+
+        // user is not logged in but has remember-me-cookie ? then try to login with cookie ("remember me" feature)
+        if (!Session::userIsLoggedIn() AND Request::cookie('remember_me')) {
+            header('location: ' . Config::get('URL') . 'login/loginWithCookie');
+        }
+
+        // create a view object to be able to use it inside a controller, like $this->View->render();
+        $this->View = new View();
+    }
+}

code/web/backend/application/core/DatabaseFactory.php

@@ -0,0 +1,46 @@
+<?php
+
+/**
+ * Class DatabaseFactory
+ *
+ * Use it like this:
+ * $database = DatabaseFactory::getFactory()->getConnection();
+ *
+ * That's my personal favourite when creating a database connection.
+ * It's a slightly modified version of Jon Raphaelson's excellent answer on StackOverflow:
+ * http://stackoverflow.com/questions/130878/global-or-singleton-for-database-connection
+ *
+ * Full quote from the answer:
+ *
+ * "Then, in 6 months when your app is super famous and getting dugg and slashdotted and you decide you need more than
+ * a single connection, all you have to do is implement some pooling in the getConnection() method. Or if you decide
+ * that you want a wrapper that implements SQL logging, you can pass a PDO subclass. Or if you decide you want a new
+ * connection on every invocation, you can do do that. It's flexible, instead of rigid."
+ *
+ * Thanks! Big up, mate!
+ */
+class DatabaseFactory
+{
+	private static $factory;
+	private $database;
+
+	public static function getFactory()
+	{
+		if (!self::$factory) {
+			self::$factory = new DatabaseFactory();
+		}
+		return self::$factory;
+	}
+
+	public function getConnection() {
+		if (!$this->database) {
+			$options = array(PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_OBJ, PDO::ATTR_ERRMODE => PDO::ERRMODE_WARNING);
+			$this->database = new PDO(
+				Config::get('DB_TYPE') . ':host=' . Config::get('DB_HOST') . ';dbname=' .
+				Config::get('DB_NAME') . ';port=' . Config::get('DB_PORT') . ';charset=' . Config::get('DB_CHARSET'),
+				Config::get('DB_USER'), Config::get('DB_PASS'), $options
+			);
+		}
+		return $this->database;
+	}
+}

code/web/backend/application/core/Environment.php

@@ -0,0 +1,18 @@
+<?php
+
+/**
+ * Class Environment
+ *
+ * Extremely simple way to get the environment, everywhere inside your application.
+ * Extend this the way you want.
+ */
+class Environment
+{
+	public static function get()
+	{
+		// if APPLICATION_ENV constant exists (set in Apache configs)
+		// then return content of APPLICATION_ENV
+		// else return "development"
+		return (getenv('APPLICATION_ENV') ? getenv('APPLICATION_ENV') : "development");
+	}
+}

code/web/backend/application/core/Mail.php

@@ -0,0 +1,115 @@
+<?php
+
+class Mail
+{
+	/** @var mixed variable to collect errors */
+	private $error;
+
+	/**
+	 * Try to send a mail by using PHP's native mail() function.
+	 * Please note that not PHP itself will send a mail, it's just a wrapper for Linux's sendmail or other mail tools
+	 *
+	 * Good guideline on how to send mails natively with mail():
+	 * @see http://stackoverflow.com/a/24644450/1114320
+	 * @see http://www.php.net/manual/en/function.mail.php
+	 */
+	public function sendMailWithNativeMailFunction()
+	{
+		// no code yet, so we just return something to make IDEs and code analyzer tools happy
+		return false;
+	}
+
+	/**
+	 * Try to send a mail by using SwiftMailer.
+	 * Make sure you have loaded SwiftMailer via Composer.
+	 *
+	 * @return bool
+	 */
+	public function sendMailWithSwiftMailer()
+	{
+		// no code yet, so we just return something to make IDEs and code analyzer tools happy
+		return false;
+	}
+
+	/**
+	 * Try to send a mail by using PHPMailer.
+	 * Make sure you have loaded PHPMailer via Composer.
+	 * Depending on your EMAIL_USE_SMTP setting this will work via SMTP credentials or via native mail()
+	 *
+	 * @param $user_email
+	 * @param $from_email
+	 * @param $from_name
+	 * @param $subject
+	 * @param $body
+	 *
+	 * @return bool
+	 * @throws Exception
+	 * @throws phpmailerException
+	 */
+	public function sendMailWithPHPMailer($user_email, $from_email, $from_name, $subject, $body)
+	{
+		$mail = new PHPMailer;
+
+		// if you want to send mail via PHPMailer using SMTP credentials
+		if (Config::get('EMAIL_USE_SMTP')) {
+			// set PHPMailer to use SMTP
+			$mail->IsSMTP();
+			// 0 = off, 1 = commands, 2 = commands and data, perfect to see SMTP errors
+			$mail->SMTPDebug = 0;
+			// enable SMTP authentication
+			$mail->SMTPAuth = Config::get('EMAIL_SMTP_AUTH');
+			// encryption
+			if (Config::get('EMAIL_SMTP_ENCRYPTION')) {
+				$mail->SMTPSecure = Config::get('EMAIL_SMTP_ENCRYPTION');
+			}
+			// set SMTP provider's credentials
+			$mail->Host = Config::get('EMAIL_SMTP_HOST');
+			$mail->Username = Config::get('EMAIL_SMTP_USERNAME');
+			$mail->Password = Config::get('EMAIL_SMTP_PASSWORD');
+			$mail->Port = Config::get('EMAIL_SMTP_PORT');
+		} else {
+			$mail->IsMail();
+		}
+
+		// fill mail with data
+		$mail->From = $from_email;
+		$mail->FromName = $from_name;
+		$mail->AddAddress($user_email);
+		$mail->Subject = $subject;
+		$mail->Body = $body;
+
+		// try to send mail
+		$mail->Send();
+
+		if ($mail) {
+			return true;
+		} else {
+			// if not successful, copy errors into Mail's error property
+			$this->error = $mail->ErrorInfo;
+			return false;
+		}
+	}
+
+	public function sendMail($user_email, $from_email, $from_name, $subject, $body)
+	{
+		if (Config::get('EMAIL_USED_MAILER') == "phpmailer") {
+			// returns true if successful, false if not
+			return $this->sendMailWithPHPMailer(
+				$user_email, $from_email, $from_name, $subject, $body
+			);
+		}
+
+		if (Config::get('EMAIL_USED_MAILER') == "swiftmailer") {
+			return $this->sendMailWithSwiftMailer();
+		}
+
+		if (Config::get('EMAIL_USED_MAILER') == "native") {
+			return $this->sendMailWithNativeMailFunction();
+		}
+	}
+
+	public function getError()
+	{
+		return $this->error;
+	}
+}

code/web/backend/application/core/Redirect.php

@@ -0,0 +1,27 @@
+<?php
+
+/**
+ * Class Redirect
+ *
+ * Simple abstraction for redirecting the user to a certain page
+ */
+class Redirect
+{
+	/**
+	 * To the homepage
+	 */
+	public static function home()
+	{
+		header("location: " . Config::get('URL'));
+	}
+
+	/**
+	 * To the defined page
+	 *
+	 * @param $path
+	 */
+	public static function to($path)
+	{
+		header("location: " . Config::get('URL') . $path);
+	}
+}

code/web/backend/application/core/Request.php

@@ -0,0 +1,53 @@
+<?php
+
+/**
+ * This is under development. Expect changes!
+ * Class Request
+ * Abstracts the access to $_GET, $_POST and $_COOKIE, preventing direct access to these super-globals.
+ * This makes PHP code quality analyzer tools very happy.
+ * @see http://php.net/manual/en/reserved.variables.request.php
+ */
+class Request
+{
+    /**
+     * Gets/returns the value of a specific key of the POST super-global.
+     * When using just Request::post('x') it will return the raw and untouched $_POST['x'], when using it like
+     * Request::post('x', true) then it will return a trimmed and stripped $_POST['x'] !
+     *
+     * @param mixed $key key
+     * @param bool $clean marker for optional cleaning of the var
+     * @return mixed the key's value or nothing
+     */
+    public static function post($key, $clean = false)
+    {
+        if (isset($_POST[$key])) {
+            // we use the Ternary Operator here which saves the if/else block
+            // @see http://davidwalsh.name/php-shorthand-if-else-ternary-operators
+            return ($clean) ? trim(strip_tags($_POST[$key])) : $_POST[$key];
+        }
+    }
+
+    /**
+     * gets/returns the value of a specific key of the GET super-global
+     * @param mixed $key key
+     * @return mixed the key's value or nothing
+     */
+    public static function get($key)
+    {
+        if (isset($_GET[$key])) {
+            return $_GET[$key];
+        }
+    }
+
+    /**
+     * gets/returns the value of a specific key of the COOKIE super-global
+     * @param mixed $key key
+     * @return mixed the key's value or nothing
+     */
+    public static function cookie($key)
+    {
+        if (isset($_COOKIE[$key])) {
+            return $_COOKIE[$key];
+        }
+    }
+}

code/web/backend/application/core/Session.php

@@ -0,0 +1,75 @@
+<?php
+
+/**
+ * Session class
+ *
+ * handles the session stuff. creates session when no one exists, sets and gets values, and closes the session
+ * properly (=logout). Not to forget the check if the user is logged in or not.
+ */
+class Session
+{
+    /**
+     * starts the session
+     */
+    public static function init()
+    {
+        // if no session exist, start the session
+        if (session_id() == '') {
+            session_start();
+        }
+    }
+
+    /**
+     * sets a specific value to a specific key of the session
+     *
+     * @param mixed $key key
+     * @param mixed $value value
+     */
+    public static function set($key, $value)
+    {
+        $_SESSION[$key] = $value;
+    }
+
+    /**
+     * gets/returns the value of a specific key of the session
+     *
+     * @param mixed $key Usually a string, right ?
+     * @return mixed the key's value or nothing
+     */
+    public static function get($key)
+    {
+        if (isset($_SESSION[$key])) {
+            return $_SESSION[$key];
+        }
+    }
+
+    /**
+     * adds a value as a new array element to the key.
+     * useful for collecting error messages etc
+     *
+     * @param mixed $key
+     * @param mixed $value
+     */
+    public static function add($key, $value)
+    {
+        $_SESSION[$key][] = $value;
+    }
+
+    /**
+     * deletes the session (= logs the user out)
+     */
+    public static function destroy()
+    {
+        session_destroy();
+    }
+
+    /**
+     * Checks if the user is logged in or not
+     *
+     * @return bool user's login status
+     */
+    public static function userIsLoggedIn()
+    {
+        return (Session::get('user_logged_in') ? true : false);
+    }
+}

code/web/backend/application/core/Text.php

@@ -0,0 +1,27 @@
+<?php
+
+class Text
+{
+    private static $texts;
+
+    public static function get($key)
+    {
+	    // if not $key
+	    if (!$key) {
+		    return null;
+	    }
+
+	    // load config file (this is only done once per application lifecycle)
+        if (!self::$texts) {
+            self::$texts = require('../application/config/texts.php');
+        }
+
+	    // check if array key exists
+	    if (!array_key_exists($key, self::$texts)) {
+		    return null;
+	    }
+
+        return self::$texts[$key];
+    }
+
+}

code/web/backend/application/core/View.php

@@ -0,0 +1,164 @@
+<?php
+
+/**
+ * Class View
+ * The part that handles all the output
+ */
+class View
+{
+    /**
+     * simply includes (=shows) the view. this is done from the controller. In the controller, you usually say
+     * $this->view->render('help/index'); to show (in this example) the view index.php in the folder help.
+     * Usually the Class and the method are the same like the view, but sometimes you need to show different views.
+     * @param string $filename Path of the to-be-rendered view, usually folder/file(.php)
+     * @param array $data Data to be used in the view
+     */
+    public function render($filename, $data = null)
+    {
+        if ($data) {
+            foreach ($data as $key => $value) {
+                $this->{$key} = $value;
+            }
+        }
+
+        require Config::get('PATH_VIEW') . '_templates/header.php';
+        require Config::get('PATH_VIEW') . $filename . '.php';
+        require Config::get('PATH_VIEW') . '_templates/footer.php';
+    }
+
+    /**
+     * Similar to render, but accepts an array of separate views to render between the header and footer. Use like
+     * the following: $this->view->renderMulti(array('help/index', 'help/banner'));
+     * @param array $filenames Array of the paths of the to-be-rendered view, usually folder/file(.php) for each
+     * @param array $data Data to be used in the view
+     * @return bool
+     */
+    public function renderMulti($filenames, $data = null)
+    {
+        if (!is_array($filenames)) {
+            self::render($filenames, $data); 
+            return false;
+        }
+
+        if ($data) {
+            foreach ($data as $key => $value) {
+                $this->{$key} = $value;
+            }
+        }
+
+        require Config::get('PATH_VIEW') . '_templates/header.php';
+
+        foreach($filenames as $filename) {
+            require Config::get('PATH_VIEW') . $filename . '.php';
+        }
+
+        require Config::get('PATH_VIEW') . '_templates/footer.php';
+    }
+
+    /**
+     * Same like render(), but does not include header and footer
+     * @param string $filename Path of the to-be-rendered view, usually folder/file(.php)
+     * @param mixed $data Data to be used in the view
+     */
+    public function renderWithoutHeaderAndFooter($filename, $data = null)
+    {
+        if ($data) {
+            foreach ($data as $key => $value) {
+                $this->{$key} = $value;
+            }
+        }
+
+        require Config::get('PATH_VIEW') . $filename . '.php';
+    }
+
+    /**
+     * Renders pure JSON to the browser, useful for API construction
+     * @param $data
+     */
+    public function renderJSON($data)
+    {
+        echo json_encode($data);
+    }
+
+    /**
+     * renders the feedback messages into the view
+     */
+    public function renderFeedbackMessages()
+    {
+        // echo out the feedback messages (errors and success messages etc.),
+        // they are in $_SESSION["feedback_positive"] and $_SESSION["feedback_negative"]
+        require Config::get('PATH_VIEW') . '_templates/feedback.php';
+
+        // delete these messages (as they are not needed anymore and we want to avoid to show them twice
+        Session::set('feedback_positive', null);
+        Session::set('feedback_negative', null);
+    }
+
+    /**
+     * Checks if the passed string is the currently active controller.
+     * Useful for handling the navigation's active/non-active link.
+     *
+     * @param string $filename
+     * @param string $navigation_controller
+     *
+     * @return bool Shows if the controller is used or not
+     */
+    public static function checkForActiveController($filename, $navigation_controller)
+    {
+        $split_filename = explode("/", $filename);
+        $active_controller = $split_filename[0];
+
+        if ($active_controller == $navigation_controller) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Checks if the passed string is the currently active controller-action (=method).
+     * Useful for handling the navigation's active/non-active link.
+     *
+     * @param string $filename
+     * @param string $navigation_action
+     *
+     * @return bool Shows if the action/method is used or not
+     */
+    public static function checkForActiveAction($filename, $navigation_action)
+    {
+        $split_filename = explode("/", $filename);
+        $active_action = $split_filename[1];
+
+        if ($active_action == $navigation_action) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Checks if the passed string is the currently active controller and controller-action.
+     * Useful for handling the navigation's active/non-active link.
+     *
+     * @param string $filename
+     * @param string $navigation_controller_and_action
+     *
+     * @return bool
+     */
+    public static function checkForActiveControllerAndAction($filename, $navigation_controller_and_action)
+    {
+        $split_filename = explode("/", $filename);
+        $active_controller = $split_filename[0];
+        $active_action = $split_filename[1];
+
+        $split_filename = explode("/", $navigation_controller_and_action);
+        $navigation_controller = $split_filename[0];
+        $navigation_action = $split_filename[1];
+
+        if ($active_controller == $navigation_controller AND $active_action == $navigation_action) {
+            return true;
+        }
+
+        return false;
+    }
+}