FuelPHP

FuelPHP is a flexible, simple, open source web application framework written in PHP that actualizes the HMVC design. FuelPHP grew out of the dissatisfactions that many individuals had with the current available frameworks and was developed with support from a group of developers. FuelPHP works with any server and prides itself on clean syntax, while being extremely portable.

In late 2010, the framework was started by Dan Horrigan then in a short time Phil Sturgeon, Jelmer Schreuder, Harro Verton, Frank de Jonge, Steve West and Márk Sági-Kazár joined the group. The group has many years of PHP experience amongst them and have all been involved with open-source projects such as CodeIgniter, PyroCMS, ExciteCMS and DataMapper ORM to name but a few.

What does FuelPHP have to offer? The following are some of the key features of FuelPHP:

• Full HMVC usage
• Package extra functionalities
• Avoid Xss attacks
• Interactive debugging, run database migrations and code generation
• Simple approach to make a RESTful API
• Provides all methods to CRUD
• Effective yet lightweight ORM
• Verification Framework
• Can utilize any layout parser for the views
• A caching system

What is FuelPHP good for?

As of now, there are lots of frameworks on the market, so why FuelPHP? Well, FuelPHP as of now takes an alternative approach as opposed to other frameworks in that it is community-driven. When creating projects, FuelPHP can be useful since it provides a solution for average web application needs. Aside from that, FuelPHP comes with support for HMVC. The delightful thing about HMVC being packaged inside the core is that upgrades will dependably bolster the modular usefulness and functionality, not to mention that you are not forced into using a modular architecture as a part of your application, but it's there if you need it. Additionally, FuelPHP also has a powerful ORM class which is useful in that it can be of great of help for a cleaner method for communicating with a database in contrast to other frameworks.

The following are some advantages of FuelPHP:

• There are very few restrictions on the most proficient method to compose code. Classes can be in any file structure.
• FuelPHP is an enormous, group-driven framework used for web development.
• Libraries and constant alterations were being produced and released which keeps the framework advancing even while the core is moving at a slower pace as of late.
• Fuel does not force you to use modules or an HMVC file structure, however in the event that one chooses to implement them, the procedure is well documented and quite easy to integrate.
• Gives a chance for one module in the new application and ended up using it for each module in this way.
• FuelPHP is fast, small and permits developers to create web based applications rapidly. It is completely extensible and includes built-in modules and package support.
• FuelPHPs’ views will encode all output to make it secure and prevent XSS assaults.

Examples and code snippets

Let’s get started working with some basics in Fuel.

Make sure to enable the following two packages in app/config/config.php :

'packages'  => array(
   'orm',
   'auth'
)

We will use this code in the next section. The default route is hello, which demonstrates your welcome page. If you would like to perform some changes, you can edit fuel/app/config/routes.php: 

return array(
   '_root_'  => 'welcome/index',  // The default route
   '_404_'   => 'welcome/404',    // The main 404 route
   'hello(/:name)?' => array('welcome/hello', 'name' => 'hello')
);

Now let's look at the proper way to say hello to the world of fuel. First, make a basic yet simple authentication app by means of Simpleauth. Simpleauth refers to a basic verification system which is incorporated into the auth package. To use Simpleauth, duplicate fuel/packages/auth/config/auth.php and simpleauth.php to fuel/app/config/. At that point, make a database table. Use migration rather than traditional database operations. Copy core/config/migrations.php to app/config/migrations.php and run the following command to create a scaffold: 

php oil generate scaffold user username:string password:string email:string profile_fields:text  created_at:string updated_at:string last_login:integer[20]

This will make a file in the app/migrations folder named 001_create_users.php, which edited as:

namespace Fuel\Migrations;
class 001_create_users
{
   public function up()
   {
    \DBUtil::create_table('users', array(
           'id' => array('constraint' => 11, 'type' => 'int', 'auto_increment' => true),
           'username' => array('constraint' => 255, 'type' => 'varchar'),
           'password' => array('constraint' => 255, 'type' => 'varchar'),
           'email' => array('constraint' => 255, 'type' => 'varchar'),
           'last_login' => array('constraint' => 20, 'type' => 'int'),
           'profile_fields' => array('constraint' => 255, 'type' => 'varchar'),
           'created_at' => array('constraint' => 255, 'type' => 'varchar'),
           'updated_at' => array('constraint' => 255, 'type' => 'varchar')
       ), array('id'));
 
       $username = "AwesomeFuel";
       $password = "@awesomeFuel@";
       $pass_hash = \Auth::instance()->hash_password($password);
       $email = "Fuel@is-awesome.au";
       $users = \Model_User::forge(array(
           'username' => $username,
           'password' => $pass_hash,
           'email' => $email,
           'profile_fields' => '',
           'last_login' => ''
       ));

       if ($users and $users->save())
           \Cli::write("the user has been created");
        else
           \Cli::write("failed to create user");
   }
   public function down()
   {
       \DBUtil::drop_table('users');
   }
}

To check the code above submit this, you will just need to run php oil refine migrate.

After this, please create a Common controller in app/classes/controller/common.php:

class controller_common extends Controller_Template
{
   public function before()
   {
       parent::before();
       $uri_string = explode('/', Uri::string());
       $this->template->logged_in = false;
 
       if (count($uri_string)>1 and $uri_string[0] == 'users' and $uri_string[1] == 'login')
           return;
        else
          {
           if(\Auth::check())
           {
               $user = \Auth::instance()->get_user_id();
               $this->user_id = $user[1];
               $this->template->logged_in = true;
           }
           else
               \Response::redirect('/users/login');
          }
   }
}

And the user controller is located in app/classes/controller/users.php:

class controller_users extends Controller_Common
{
   public function action_index()
   {
       $data['users'] = Model_User::find('all');
       $this->template->title = "Users";
       $this->template->content = View::forge('users/index', $data);
   }
 
   public function action_login()
   {
       if (Auth::check())
           Response::redirect('/');
       $val = Validation::forge('users');
       $val->add_field('username', 'Your username', required|min_length[3]|max_length[20]');
       $val->add_field('password', 'Your password', required|min_length[3]|max_length[20]');
 
       if ($val->run())
       {
           $auth = Auth::instance();
           if ($auth->login($val->validated('username'), $val->validated('password')))
           {
               Session::set_flash('notice', 'FLASH: logged in');
               Response::redirect('users');
           }
           else
           {
               $data['username'] = $val->validated('username');
               $data['errors'] = 'Wrong username/password. Try again';
           }
       }
       else
       {
           if ($_POST)
           {
               $data['username'] = $val->validated('username');
               $data['errors'] = 'Wrong username/password combo. Try again';
           }
           else
           {
               $data['errors'] = false;
           }
       }
 
      $this->template->errors = $data['errors'];
      $this->template->content = View::forge('users/login')->set($data);
   }
 
   public function action_view($id = null)
   {
       $data['user'] = Model_User::find($id);
       $this->template->title = "User";
       $this->template->content = View::forge('users/view', $data);
   }
 
   public function action_logout()
   {
       Auth::instance()->logout();
       Response::redirect('/');
   }
}

As what you can see, the controller extends Controller_Common in order to be restricted by log-in. Additionally, the input data in the controller is also validated, but it could be in the model, as well.

Once you're done with the controllers it's time to make a view for the application. In Fuel, the view files are situated under app/views/CONTROLLERNAME/. The first view to make is app/views/users/login.php:

<h2>Login</h2>
Login to your account using your username and password.
<div class="input required">
   <?php isset($errors) ? $errors : false; ?>
   <?php echo Form::open('users/login'); ?>
   <?php echo Form::label('Username', 'username'); ?>
   <?php echo Form::input('username', null, array('size' => 30)); ?>
</div>
 
<div class="input password required">
   <?php echo Form::label('Password', 'password'); ?>
   <?php echo Form::password('password', null, array('size' => 30)); ?>
</div>
 
<div class="submit" >
   <?php echo Form::submit('login', 'Login'); ?>
</div>

And now, the index.php file:

<div><?php echo $user->username; ?></div>

Then navigate http://127.0.0.1/public/users/login in your browser. Enjoy!! 

Conclusions

Web development is a dynamic field with new and innovative techniques being developed all the time. Numerous PHP frameworks offer broad, extensive designs with exclusive features that make source code programming less confounded by giving standard templates and plugins. If you are concerned that a framework lacks an authentication library, ORM and PHP5 compatibility, then FuelPHP is presumably the perfect choice. FuelPHP is another section of the IT market. FuelPHP is a nice bridge framework for a Codeigniter developer. The structure is generally the same, expectation to learn and adapt is for the most part the same and the documentation is getting very strong. FuelPHP does a lot of heavy lifting for you. Everything is up to you on what framework are you comfortable with. So if you're looking to broaden your expertise, then FuelPHP may be the right framework for you.