sippy
1.0
Un cadre PHP léger et facile à utiliser pour créer des sites Web et des applications Web.
L'architecture de Sippy a une ressemblance frappante avec Codeigniter, nous l'appelons donc un cadre PHP léger. Cependant, n'oubliez pas que parce que SIPPY est léger, il n'inclut pas beaucoup de fonctionnalités fournies avec CodeIgniter. Peut-être que nous pouvons ajouter des fonctionnalités "plug-n-play" via des plug-ins, des contrôleurs et des bibliothèques. Pour utiliser, supprimez le "exemple" du fichier de configuration dans l'application / config / samptample.config.php donc il s'agit donc d'application / config / config.php et de remplir vos données de configuration.
Sippy est basé sur le modèle de développement de contrôle-contrôle de modèle.
Les fichiers spécifiques à votre application vont dans le dossier "Application" (vous n'avez pas besoin de toucher le dossier système). À l'intérieur du dossier d'application, il existe des dossiers pour toutes les entités d'application spécifiques:
Config Controllers Helers Journals modèles Plugins Vues Plugins
Lorsque Sippy charge les fichiers, il suppose qu'ils sont dans les dossiers correspondants. Assurez-vous donc de placer vos fichiers dans les dossiers appropriés.
Nous vous encourageons à utiliser le dossier "Assets" dans la racine pour stocker vos fichiers de ressources statiques (CSS, JS, etc.), mais vous pouvez les mettre n'importe où. Vous pouvez également utiliser la fonction site_url() pour vous aider à inclure des fichiers dans votre HTML ou utiliser site_url('main/index') pour accéder à la page http://www.yoursite.com/main/index . Par exemple:
< link rel =" stylesheet " href =" <?php echo site_url(); ?>assets/css/style.css " type =" text/css " media =" screen " />Toutes les classes de Sippy utilisent la dénomination de Pascalcase. Les noms de fichiers associés doivent être les mêmes sauf toutes les minuscules. Ainsi, par exemple, la classe MainClass aurait le nom de fichier Mainclass.php. Les soulignements dans les classes doivent également être inclus dans les noms de fichiers.
Par défaut, les URL dans Sippy sont conçues pour être des moteurs de recherche et des amies humaines. Plutôt que d'utiliser l'approche standard de la "chaîne de requête" des URL synonymes de systèmes dynamiques, Sippy utilise une approche basée sur le segment:
example.com/class/function/param Par défaut, index.php est caché dans l'URL. Cela se fait à l'aide du fichier .htaccess dans le répertoire racine.
Il suffit de mettre des fichiers dans votre projet pour une authentification facile: https://github.com/trafficinc/sippy-auth
Les contrôleurs sont la force motrice d'une application sippy. Comme vous pouvez le voir dans la structure de l'URL, les segments de l'URL sont mappés en classe et en fonction. Ces classes sont des contrôleurs stockés dans le répertoire "Application / Controller". Ainsi, par exemple l'URL ...
example.com/main/login ... pourrait mapper au contrôleur suivant avec le nom de fichier main.php:
<?php
class Main extends Sippy_controller {
function index () {
// This is the default function (i.e. no function is set in the URL)
}
function login () {
echo ' Hello World! ' ;
}
}... et la production serait "Hello World!".
Le contrôleur par défaut et le contrôleur d'erreur peuvent être définis dans l'application / config / config.php
Notez que si vous devez déclarer un constructeur, vous devez également appeler le constructeur parent comme:
<?php
class Example extends Sippy_controller {
public function __construct ()
{
parent :: __construct ();
// Your own constructor code
}
}
?>Il existe plusieurs fonctions d'assistance qui peuvent également être utilisées dans les contrôleurs. La plupart de ces fonctions prennent le nom de paramètre $ de la classe correspondante:
Les erreurs de journalisation et les informations de débogage
Ensuite, vous pouvez ajouter ce code à votre contrôleur pour le débogage.
log_message('error','Your log message');log_message('debug','Your log message');Exemple de validation du contrôleur et de messages CSRF Token Protection & Flash Erreur / Succès: #Controller `` `Besoin System_Dir. '/ Validation.php'; ###### - Classe - Validation $ protégé;
function __constructor() {
$this->validation = new Validation;
}
$data['messSuccess'] = $this->flash->message('success');
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
if ($_POST['csrf'] === $_SESSION['csrf_token']) {
$validator = $this->validation->go($_POST, [
'email' => 'required|min:5',
'password' => 'required',
]);
if (count($validator) > 0) {
$data['errors'] = $validator;
} else {
// ** Do Stuff **
$this->flash->message('success','Your flash message here');
$this->redirect('auth/login');
}
}
}
```
#voir
<h1>Login</h1>
<?php
if (isset($messSuccess)) {
$this->success_block($messSuccess);
}
if (isset($errors)) {
$this->error_block($errors);
}
?>
<form method="post" action="<?php echo site_url('auth/login'); ?>">
<input type="hidden" name="csrf" value="<?php echo $this->security->generate_csrf_token(); ?>"/>
<div class="form-group">
<label for="email">Email address</label>
<input type="email" name="email" class="form-control" id="email" placeholder="Email">
</div>
<div class="form-group">
<label for="password">Password</label>
<input type="password" name="password" class="form-control" id="password" placeholder="Password">
</div>
<button type="submit" class="btn btn-default">Login</button>
</form>
Dans Sippy, une vue est simplement une page Web. Ils peuvent contenir tout ce qu'une page Web normale inclurait. Les vues sont presque toujours chargées par les contrôleurs. Ainsi, par exemple, si vous aviez une vue appelée main_view.php qui contenait le HTML suivant:
<html>
<head>
<title>My Site</title>
</head>
<body>
<h1>Welcome to my Site!</h1>
</body>
</html>
. . . you would load it in a controller by doing the following:
// Controller file...
<?php
class Main extends Sippy_controller {
function index ()
{
$ template = $ this -> View ( ' main_view ' );
$ template -> render ();
}
} La classe de vue a une fonction d'assistance appelée set($key, $val) qui vous permet de passer des variables du contrôleur à la vue.
$ template = $ this -> View ( ' main_view ' );
$ template -> set ( ' someval ' , 17 );
$ template -> render ();... Ensuite, dans la vue, vous pourriez faire:
<?php echo $someval; ?>
... et la sortie serait 17. Tout type de variable PHP peut être transmis à une vue de cette manière: tableaux, etc.
OU
Dans le contrôleur, vous pouvez appeler vos vues avec des données qui seront ensuite disponibles dans la vue. Cela peut être réalisé aux moyens. Dans le contrôleur ...
$ header = array ( ' title ' => ' My Title ' , ' descr ' => ' Login Page ' , ' keywords ' => ' login,page,mysample ' );
$ template = $ this -> View ( ' main/index ' , $ d );Dans la vue, ces éléments de tableau sont accessibles comme ça ...
<?php echo $title; ?>
Qui montrera le texte "mon titre", et ainsi de suite pour le reste du tableau.
La façon préférée d'accéder aux données dans les vues est de nommer le tableau de données et d'y accéder dans le contrôleur comme ça ...
$ data [ ' body ' ] = " Hello World " ;
$ data [ ' heading ' ] = array ( ' title ' => ' My Title ' , ' descr ' => ' Login Page ' , ' keywords ' => ' login,page,mysample ' );
$ template = $ this -> View ( ' main/index ' , $ data );puis dans la vue ...
//body can be accessed
<?php echo $ body ; ?>
//heading can be accessed as an array
<?php
foreach ( $ heading as $ head ) {
echo $ head [ ' title ' ];
. . . etc.
}
?> Dans les modèles SIPPY se trouvent des classes qui traitent des données (généralement à partir d'une base de données), une base d'échantillonnage de données est fournie, chargez le fichier testdb.sql dans Suite Pro ou votre interface graphique SQL de choix. Par exemple:
<?php
class Example_model extends Sippy_model {
public function getSomething ( $ id )
{
$ id = $ this -> escape ( $ id );
$ result = $ this -> query ( " SELECT * FROM something WHERE id=' { $ id } ' " );
return $ result ;
}
}
?>... Ensuite, dans un contrôleur, vous feriez:
function index ()
{
$ example = $ this -> Model ( ' Example_model ' );
$ data [ ' something ' ] = $ example -> getSomething ( $ id );
$ template = $ this -> View ( ' main_view ' , $ data );
$ template -> render ();
} Désormais, les résultats de votre requête de base de données seraient disponibles dans votre avis dans $ Someval. La connexion à la base de données MySQL peut être effectuée dans votre fichier config/config.php (n'oubliez pas de renommer le fichier sample.config.php ):
$ config [ ' db_host ' ] = '' ; // Database host (e.g. localhost)
$ config [ ' db_name ' ] = '' ; // Database name
$ config [ ' db_username ' ] = '' ; // Database username
$ config [ ' db_password ' ] = '' ; // Database passwordIl existe plusieurs fonctions d'assistance qui peuvent également être utilisées dans les modèles:
query($query) - Renvoie un tableau de résultats d'une requêtegetrow($query) - Renvoie une ligne de la requêtegetrowobj($query) - Renvoie une ligne en tant qu'objetexecute($query) - Renvoie le résultat direct d'une requêteescape($string) - Échappez les chaînes avant de les utiliser dans les requêtesinsert($table, $dataArray) - Insérer dans une table avec un tableauIl y a une aide HTML cuite au four que vous pouvez utiliser dans les contrôleurs et les vues via $ this-> html-> esc () et plus, dans votre URL lorsque vous exécutez SIPPY, accédez à URL Main / test pour voir les fonctionnalités disponibles.
Il existe deux types de ressources supplémentaires que vous pouvez utiliser dans Sippy.
Les aides sont des classes que vous pouvez utiliser qui ne relèvent pas de la catégorie des "contrôleurs". Ce seront généralement des classes qui offrent des fonctionnalités supplémentaires que vous pouvez utiliser dans vos contrôleurs. Sippy est livré avec des classes d'assistance (Session_Helper et URL_HELPER) qui sont des exemples d'utilisation des aides.
Les plugins sont littéralement des fichiers PHP et peuvent fournir toutes les fonctionnalités que vous souhaitez. En chargeant un plugin, vous incluez simplement le fichier PHP du dossier "Plugins". Cela peut être utile si vous souhaitez utiliser des bibliothèques tierces dans votre application Sippy.
Comment utiliser, dans Controller ...
protected $sess;
public function __construct() {
parent::__construct();
$this->Helper('Session_helper');
$this->sess = new Session_helper;
}
public function sample() {
$this->sess->set('email', '[email protected]'); //set session variable
$this->sess->get('email'); //get session variable
$this->sess->destroy(); //destroy session, good for logout method
}
Comment utiliser, dans Controller ...
public function __construct() {
parent::__construct();
$this->Plugin('Mailer');
}
public function sample() {
$send = Mailer::make()
->setTo('[email protected]', 'ToPerson')
->setFrom('[email protected]', 'Sippy')
->setSubject('Hello World Test')
->setMessage('Test message form sippy')
->setHtml()
->setWrap(100)
->send();
}
Pour étendre Sippy, il y a une option pour ajouter des «crochets». Les crochets vous permettent d'étendre l'ensemble du cadre et / ou d'ajouter des fonctionnalités. Pour activer les «crochets», accédez à votre fichier config.php et activez-le. Ensuite, dans le fichier config / hooks.php, ajoutez votre fonction Hook. Les crochets sont mondiaux et il y en a trois; before_system (charge avant les appels système), before_controller (charge avant les contrôleurs) et after_controller (charge après contrôleurs). Voici un exemple ...
// in hooks.php file
$ hook [ ' before_system ' ] = function () {
echo " hello world " ;
};Ce crochet chargera à l'échelle mondiale de cette fonction qui dit «Bonjour le monde». Étant donné que vous ne pouvez charger un crochet qu'une seule fois, si vous avez plus d'une fonction à appeler, vous pouvez les empiler comme ça ...
//... your functions ... function func1() {...do stuff...}
$ hook [ ' before_system ' ] = function () {
func1 ();
func2 ();
func3 ();
};$ php bin / sippy.php [Options]
essayer
$ php bin / sippy.php -help
