Example #1
0
 /**
  * send, Envoie le mail
  *
  * @param Message $message
  * @throws InvalidArgumentException
  * @throws MailException
  * @return bool
  */
 public function send(Message $message)
 {
     if (empty($message->getTo()) || empty($message->getSubject()) || empty($message->getMessage())) {
         throw new InvalidArgumentException("Une erreur est survenu. L'expediteur ou le message ou l'object omit.", E_USER_ERROR);
     }
     if (isset($this->config['mail'])) {
         $section = $this->config['mail']['default'];
         if (!$message->fromIsDefined()) {
             $form = $this->config['mail'][$section];
             $message->from($form["address"], $form["username"]);
         } else {
             if (!Str::isMail($message->getFrom())) {
                 $form = $this->config['mail'][$message->getFrom()];
                 $message->from($form["address"], $form["username"]);
             }
         }
     }
     $to = '';
     $message->setDefaultHeader();
     foreach ($message->getTo() as $value) {
         if ($value[0] !== null) {
             $to .= $value[0] . ' <' . $value[1] . '>';
         } else {
             $to .= '<' . $value[1] . '>';
         }
     }
     $status = @mb_send_mail($to, $message->getSubject(), $message->getMessage(), $message->compileHeaders());
     return (bool) $status;
 }
Example #2
0
 /**
  * Facade, implementation de la fonction magic __callStatic de PHP
  *
  * @param string $method Le nom de la method a appelé
  * @param array $args    Les arguments a passé à la fonction
  * @throws ModelException
  * @return \Bow\Database\Table
  */
 public static function __callStatic($method, $args)
 {
     $scope = 'scope' . ucfirst($method);
     $table = Database::table(Str::lower(static::$table));
     /**
      * Lancement de l'execution des fonctions aliase définir dans les classe
      * héritant de la classe Model.
      *
      * Les classes  definir définir avec la montion scope.
      */
     if (method_exists($child = new static(), $scope)) {
         if (method_exists($table, $method)) {
             throw new ModelException($method . ' ne peut pas être utiliser comme fonction d\'aliase.', E_ERROR);
         }
         return call_user_func_array([$child, $scope], $args);
     }
     /**
      * Lancement de l'execution des fonctions liée a l'instance de la classe Table
      */
     if (method_exists($table, $method)) {
         $table = call_user_func_array([$table, $method], $args);
         return static::carbornize($table, $method, $child);
     }
     throw new ModelException('methode ' . $method . ' n\'est définie.', E_ERROR);
 }
Example #3
0
 /**
  * Session starteur.
  */
 private static function start()
 {
     if (PHP_SESSION_ACTIVE != session_status()) {
         session_name("SESSID");
         if (!isset($_COOKIE["SESSID"])) {
             session_id(hash("sha256", Security::encrypt(Str::repeat(Security::generateCsrfToken(), 2))));
         }
         session_start();
     }
 }
Example #4
0
 /**
  * retourne la langue de la requête.
  *
  * @return string|null
  */
 public function language()
 {
     return Str::slice($this->locale(), 0, 2);
 }
Example #5
0
 /**
  * env manipule les variables d'environement du server.
  *
  * @param $key
  * @param null $value
  *
  * @return bool|string
  */
 function env($key, $value = null)
 {
     if ($value !== null) {
         return getenv(\Bow\Support\Str::upper($key));
     } else {
         return putenv(\Bow\Support\Str::upper($key) . '=' . $value);
     }
 }
Example #6
0
 /**
  * templateLoader, charge le moteur template à utiliser.
  *
  * @throws ErrorException
  * @return \Twig_Environment|\Mustache_Engine|\Jade\Jade
  */
 private function templateLoader()
 {
     if ($this->config->getTemplateEngine() !== null) {
         if (!in_array($this->config->getTemplateEngine(), ['twig', 'mustache', 'jade'], true)) {
             throw new ErrorException('Le moteur de template n\'est pas implementé.', E_USER_ERROR);
         }
     } else {
         throw new ResponseException('Le moteur de template non défini.', E_USER_ERROR);
     }
     $tpl = null;
     if ($this->config->getTemplateEngine() == 'twig') {
         $loader = new \Twig_Loader_Filesystem($this->config->getViewpath());
         $tpl = new \Twig_Environment($loader, ['cache' => $this->config->getCachepath(), 'auto_reload' => $this->config->getCacheAutoReload(), 'debug' => $this->config->getLoggerMode() == 'develepment' ? true : false]);
         /**
          * - Ajout de variable globale
          * dans le cadre de l'utilisation de Twig
          */
         $tpl->addGlobal('public', $this->config->getPublicPath());
         $tpl->addGlobal('root', $this->config->getApproot());
         /**
          * - Ajout de fonction global
          *  dans le cadre de l'utilisation de Twig
          */
         $tpl->addFunction(new \Twig_SimpleFunction('secure', function ($data) {
             return Security::sanitaze($data, true);
         }));
         $tpl->addFunction(new \Twig_SimpleFunction('sanitaze', function ($data) {
             return Security::sanitaze($data);
         }));
         $tpl->addFunction(new \Twig_SimpleFunction('csrf_field', function () {
             return Security::getCsrfToken()->field;
         }));
         $tpl->addFunction(new \Twig_SimpleFunction('csrf_token', function () {
             return Security::getCsrfToken()->token;
         }));
         $tpl->addFunction(new \Twig_SimpleFunction('slugify', [Str::class, 'slugify']));
         return $tpl;
     }
     if ($this->config->getTemplateEngine() == 'mustache') {
         return new \Mustache_Engine(['cache' => $this->config->getCachepath(), 'loader' => new \Mustache_Loader_FilesystemLoader($this->config->getViewpath()), 'helpers' => ['secure' => function ($data) {
             return Security::sanitaze($data, true);
         }, 'sanitaze' => function ($data) {
             return Security::sanitaze($data);
         }, 'slugify' => function ($data) {
             return Str::slugify($data);
         }, 'csrf_token' => function () {
             return Security::getCsrfToken()->token;
         }, 'csrf_field' => function () {
             return Security::getCsrfToken()->field;
         }, 'public', $this->config->getPublicPath(), 'root', $this->config->getApproot()]]);
     }
     return new Jade(['cache' => $this->config->getCachepath(), 'prettyprint' => true, 'extension' => $this->config->getTemplateExtension()]);
 }
Example #7
0
 /**
  * Tout les marqueurs possible.
  *
  * - required   Vérifie que le champs existe dans les données à valider
  * - min:value  Vérifie que le contenu du champs est un nombre de caractère minimal suivant la valeur définie
  * - max:value  Vérifie que le contenu du champs est un nombre de caractère maximal suivant la valeur définie
  * - size:value Vérifie que le contenu du champs est un nombre de caractère égale à la valeur définie
  * - eq:value   Vérifie que le contenu du champs soit égale à la valeur définie
  * - email      Vérifie que le contenu du champs soit une email
  * - number     Vérifie que le contenu du champs soit un nombre
  * - alphanum   Vérifie que le contenu du champs soit une chaine alphanumérique
  * - alpha      Vérifie que le contenu du champs soit une alpha
  * - upper      Vérifie que le contenu du champs soit une chaine en majiscule
  * - lower      Vérifie que le contenu du champs soit une chaine en miniscule
  * - in:(value, ..) Vérifie que le contenu du champs soit une parmis les valeurs définies.
  *
  * e.g: required|max:255
  *      required|email|min:49
  *      required|confirmed
  *
  * @param array $inputs Les informations a validé
  * @param array $rules Le critaire de validation
  *
  * @return Validate
  */
 public static function make(array $inputs, array $rules)
 {
     $isFails = false;
     $errors = [];
     $message = "";
     foreach ($rules as $key => $rule) {
         /**
          * Formatage et validation de chaque règle
          * eg. name => "required|max:100|alpha"
          */
         foreach (explode("|", $rule) as $masque) {
             // Dans le case il y a un | superflux.
             if (is_int($masque) || Str::len($masque) == "") {
                 continue;
             }
             // Erreur listes.
             $errors[$key] = [];
             // Masque sur la règle required
             if ($masque == "required") {
                 if (!isset($inputs[$key])) {
                     $message = "Le champs \"{$key}\" est requis.";
                     $errors[$key][] = ["masque" => $masque, "message" => $message];
                     $isFails = true;
                 }
             } else {
                 if (!isset($inputs[$key])) {
                     $message = "Le champs \"{$key}\" n'est pas défini dans les données à valider.";
                     $errors[$key][] = ["masque" => $masque, "message" => $message];
                     $isFails = true;
                     continue;
                 }
             }
             // Masque sur la règle min
             if (preg_match("/^min:(\\d+)\$/", $masque, $match)) {
                 $length = (int) end($match);
                 if (Str::len($inputs[$key]) < $length) {
                     $message = "Le champs \"{$key}\" doit avoir un contenu minimal de {$length}.";
                     $errors[$key][] = ["masque" => $masque, "message" => $message];
                     $isFails = true;
                 }
             }
             // Masque sur la règle max
             if (preg_match("/^max:(\\d+)\$/", $masque, $match)) {
                 $length = (int) end($match);
                 if (Str::len($inputs[$key]) > $length) {
                     $message = "Le champs \"{$key}\" doit avoir un contenu maximal de {$length}.";
                     $errors[$key][] = ["masque" => $masque, "message" => $message];
                     $isFails = true;
                 }
             }
             // Masque sur la règle size
             if (preg_match("/^size:(\\d+)\$/", $masque, $match)) {
                 $length = (int) end($match);
                 if (Str::len($inputs[$key]) == $length) {
                     $message = "Le champs \"{$key}\" doit avoir un contenu de {$length} caractère(s).";
                     $errors[$key][] = ["masque" => $masque, "message" => $message];
                     $isFails = true;
                 }
             }
             // Masque sur la règle in
             if (preg_match("/^in:\\((.+)\\)\$/", $masque, $match)) {
                 $values = explode(",", end($match));
                 foreach ($values as $index => $value) {
                     $values[$index] = trim($value);
                 }
                 if (!in_array($inputs[$key], $values)) {
                     $message = "Le champs \"{$key}\" doit avoir un contenu une valeur dans " . implode(", ", $values) . ".";
                     $errors[$key][] = ["masque" => $masque, "message" => $message];
                     $isFails = true;
                 }
             }
             // Masque sur la règle eq
             if (preg_match("/^eq:(.+)\$/", $masque, $match)) {
                 $value = (string) end($match);
                 if ($inputs[$key] == $value) {
                     $message = "Le champs \"{$key}\" doit avoir un contenu égal à '{$value}'.";
                     $errors[$key][] = ["masque" => $masque, "message" => $message];
                     $isFails = true;
                 }
             }
             // Masque sur la règle email.
             if (preg_match("/^email\$/", $masque, $match)) {
                 if (!Str::isMail($inputs[$key])) {
                     $message = "Le champs {$key} doit avoir un contenu au format email.";
                     $errors[$key][] = ["masque" => $masque, "message" => $message];
                     $isFails = true;
                 }
             }
             // Masque sur la règle number
             if (preg_match("/^number\$/", $masque, $match)) {
                 if (!is_numeric($inputs[$key])) {
                     $message = "Le champs \"{$key}\" doit avoir un contenu en numérique.";
                     $errors[$key][] = ["masque" => $masque, "message" => $message];
                     $isFails = true;
                 }
             }
             // Masque sur la règle alphanum
             if (preg_match("/^alphanum\$/", $masque)) {
                 if (!Str::isAlphaNum($inputs[$key])) {
                     $message = "Le champs \"{$key}\" doit avoir un contenu en alphanumérique.";
                     $errors[$key][] = ["masque" => $masque, "message" => $message];
                     $isFails = true;
                 }
             }
             // Masque sur la règle upper
             if (preg_match("/^upper/", $masque)) {
                 if (!Str::isUpper($inputs[$key])) {
                     $message = "Le champs \"{$key}\" doit avoir un contenu en majiscule.";
                     $errors[$key][] = ["masque" => $masque, "message" => $message];
                     $isFails = true;
                 }
             }
             // Masque sur la règle lower
             if (preg_match("/^lower/", $masque)) {
                 if (!Str::isLower($inputs[$key])) {
                     $message = "Le champs \"{$key}\" doit avoir un contenu en miniscule.";
                     $errors[$key][] = ["masque" => $masque, "message" => $message];
                     $isFails = true;
                 }
             }
             // Masque sur la règle alpha
             if (preg_match("/^alpha\$/", $masque)) {
                 if (!Str::isAlpha($inputs[$key])) {
                     $message = "Le champs \"{$key}\" doit avoir un contenu en alphabetique.";
                     $errors[$key][] = ["masque" => $masque, "message" => $message];
                     $isFails = true;
                 }
             }
             // On nettoye la lsite des erreurs si la clé est valide
             if (empty($errors[$key])) {
                 unset($errors[$key]);
             }
         }
     }
     return new Validate($isFails, $message, $errors);
 }
Example #8
0
 /**
  * where, ajout condition de type where, si chainé ajout un <<and>>
  *
  * WHERE column1 $comp $value|column
  *
  * @param $column
  * @param $comp
  * @param null $value
  * @param $boolean
  *
  * @throws TableException
  *
  * @return $this
  */
 public function where($column, $comp = '=', $value = null, $boolean = 'and')
 {
     if (!static::isComporaisonOperator($comp)) {
         $value = $comp;
         $comp = '=';
     }
     // Ajout de matcher sur id.
     if ($comp == '=' && $value === null) {
         $value = $column;
         $column = 'id';
     }
     if ($value === null) {
         throw new TableException('valeur de comparaison non définir', E_ERROR);
     }
     if (!in_array(Str::lower($boolean), ['and', 'or'])) {
         throw new TableException('le booléen ' . $boolean . ' non accepté', E_ERROR);
     }
     $this->whereDataBind[$column] = $value;
     if ($this->where == null) {
         $this->where = $column . ' ' . $comp . ' :' . $column;
     } else {
         $this->where .= ' ' . $boolean . ' ' . $column . ' ' . $comp . ' :' . $column;
     }
     return $this;
 }
Example #9
0
 /**
  * fillTable, remplir un table pour permet le developpement.
  *
  * @param string|array $table [optional]
  * @param int $n
  * @param array $desciption [
  *      "column" => [
  *          "field" => "name",
  *          "type": "int|longint|bigint|mediumint|smallint|tinyint",
  *          "auto" => false|true
  *      ]
  * @return mixed
  */
 public static function fillTable($table = null, $n = 1, $desciption = [])
 {
     if (is_int($table)) {
         $n = $table;
         $table = null;
     }
     if (!is_string($table)) {
         $table = static::$table;
     }
     $database = Database::table($table);
     if (static::$data === null) {
         static::$data = $desciption;
     }
     $r = 0;
     for ($i = 0; $i < $n; $i++) {
         $data = [];
         foreach (static::$data as $column) {
             if (in_array($column['type'], ['int', 'longint', 'bigint', 'mediumint', 'smallint', 'tinyint'])) {
                 if ($column['auto']) {
                     $value = null;
                 } else {
                     $value = Filler::number();
                 }
             } else {
                 if (in_array($column['type'], ['date', 'datetime'])) {
                     $value = Filler::date();
                 } else {
                     if (in_array($column['type'], ['double', 'float'])) {
                         $value = Filler::float();
                     } else {
                         if ($column['type'] == 'timestamp') {
                             $value = time();
                         } else {
                             if ($column['type'] == 'enum') {
                                 $value = $column['default'];
                             } else {
                                 if (preg_match('/text$/', $column['type'])) {
                                     $value = Str::slice(Filler::string(), 0, 1000);
                                 } else {
                                     $value = Str::slice(Filler::string(), 0, rand(1, $column['size']));
                                 }
                             }
                         }
                     }
                 }
             }
             $data[$column['field']] = $value;
         }
         $r += $database->insert($data);
     }
     return $r;
 }
Example #10
0
 /**
  * @return string
  */
 public static function unique()
 {
     return Str::lower(uniqid());
 }
Example #11
0
 /**
  * connection, lance la connection sur la DB
  *
  * @param null $zone
  * @param null $cb
  * @return null|Database
  */
 public static function connection($zone = null, $cb = null)
 {
     if (static::$db instanceof PDO) {
         return static::takeInstance();
     }
     if (!static::$config instanceof StdClass) {
         return Util::launchCallback($cb, [new ConnectionException("Le fichier database.php est mal configurer")]);
     }
     if (is_callable($zone)) {
         $cb = $zone;
         $zone = null;
     }
     if ($zone != null) {
         static::$zone = $zone;
     }
     $c = isset(static::$config->connections[static::$zone]) ? static::$config->connections[static::$zone] : null;
     if (is_null($c)) {
         Util::launchCallback($cb, [new ConnectionException("La clé '" . static::$zone . "' n'est pas définir dans l'entre database.php")]);
     }
     $db = null;
     try {
         // Variable contenant les informations sur
         // utilisateur
         $username = null;
         $password = null;
         // Configuration suppelement coté PDO
         $pdoPostConfiguation = [PDO::ATTR_DEFAULT_FETCH_MODE => static::$config->fetch];
         switch ($c["scheme"]) {
             case "mysql":
                 // Construction de la dsn
                 $dns = "mysql:host=" . $c["mysql"]['hostname'] . ($c["mysql"]['port'] !== null ? ":" . $c["mysql"]["port"] : "") . ";dbname=" . $c["mysql"]['database'];
                 $username = $c["mysql"]["username"];
                 $password = $c["mysql"]["password"];
                 $pdoPostConfiguation[PDO::MYSQL_ATTR_INIT_COMMAND] = "SET NAMES " . Str::upper($c["mysql"]["charset"]);
                 break;
             case "sqlite":
                 $dns = $c["sqlite"]["driver"] . ":" . $c["sqlite"]["database"];
                 break;
             default:
                 throw new DatabaseException("Vérifiez la configuration de la base de donnée.", E_USER_ERROR);
                 break;
         }
         // Connection à la base de donnée.
         static::$db = new PDO($dns, $username, $password, $pdoPostConfiguation);
     } catch (PDOException $e) {
         /**
          * Lancement d'exception
          */
         static::$errorInfo = [$e->getCode(), true, $e->getMessage()];
         Util::launchCallback($cb, [$e]);
     }
     Util::launchCallback($cb, [false]);
     return static::class;
 }
Example #12
0
 /**
  * Formaté l'email récu.
  *
  * @param  string $email
  * @param  string $name
  *
  * @return array
  */
 private function formatEmail($email, $name = null)
 {
     /**
      * Organisation de la liste des senders
      */
     if (!is_string($name) && preg_match('/^(.+)\\s+<(.*)>\\z$/', $email, $matches)) {
         array_shift($matches);
         $name = $matches[0];
         $email = $matches[1];
     }
     if (!Str::isMail($email)) {
         throw new \InvalidArgumentException("{$email} n'est pas email valide.", E_USER_ERROR);
     }
     return [$name, $email];
 }