INSTALLATION


The Jet Engine features a completely web-based installation system. When you want to start a new Jet Application, simply extract/upload the core files into the directory on your web server where you want it to run, navigate there with your browser. You'll be greeted with a friendly, step-by-step installation program that will take care of everything for you.

If you're an applications developer, this is an extra bonus for you, because when you ship your application to your client, all you need to do is to zip up your working directory (which includes the core jet system, plus your application extensions) and that same installer works on your client's website as well.

ADMINISTRATION


The Jet Engine is, at it's very core, a Web Application Framework, not just a PHP Framework.

What this means, quite simply, is that we designed it from the outset to service some sort of web based application. What does every web application have (or need)? An online administration area ... a place where the end user can set options, and manage the application that you've written for them.

We're certainly preaching to the choir here: It's drudgery to setup an admin area. Not so much the parts where you're writing reports or letting users manage data, but all the setup stuff, the options screens, etc. It's a real pain ... which is why The Jet Engine comes with a complete admin center built in, so you don't have to do any of that. All you need to do is write the admin tools that are relevant to your application.

1. Preferences/Options Editor
   All you need to do is to define the options specific to your application (this is just a JSON file that you upload into your application's directory). The Jet's admin area will automatically create the menu items for your applications options and the form to take that input from the end user.
2. Template Editors
   We include a full template editing system directly into the admin center. This will allow the user to edit the full page templates and sub templates that make up your application, which will then use the iTemplate System to merge your program output with your client's HTML design.
3. Application and Plugin Editors
   You can create new applications from within the admin center, and edit the source code for your application directly online through the admin interface. 90% of the time, you're going to want to work offline with your own editor, but if a client needs a quick fix made to your app, you can quickly login and get that done through the admin tools very easily.
   
   You may also create and edit plugin extensions (mini php-applications) for inclusion in your application/template from within the admin center.
4. Database Schema Editors
   The Jet Engine uses the iSQL Database Record system, which allows you to very easily work with SQL table data. Part of the magic behind that system is the "Database Table Schemas", which allow you fine-tune your SQL Tables. For each table, you define not only the type of data (integer, etc), but the form prompts to use, the type of input (text box, select, radio, etc), allowed values, etc. Once you setup your table schema, all of the input forms that reference that table will use these settings to create the form the way you want it, and will do all error checking based on your preferences.
5. Ease of Integration
   It's amazingly easy to integrate your program into the Jet Admin Interface. Essentially, you define any preferences/options in one file, and all of your admin functions in another one. The system will use that second file to create a drop down menu with all of your admin functions (reports, data management, etc) in it. Each drop down menu item will have 3 very important paramaters -- The name of the menu item, the URL to open when clicked, and the user permissions required to run it. (admin users without the right permission level will not even see those menu items).
   
   As far as "hooking in" ... all you need to do is create an admin.php (using a template that we provide) that has functions named to match the URL action. i.e. /admin.php?admin=YOURPROGRAM&action=list_users would look for a function called "list_users()" in the admin.php file in the YOURPROGRAM directory. The admin center fires itself up, loads up your admin, runst that function, and echo's out the return value. Simple as that.
6. Fully Branded
   We provide a set of admin templates that allows you to fully brand the admin center itself with your own logo, color schemes, etc. The generic ones work and look great, of course ... but you can put your own stamp on it and make it work and look the way you want it to, all without worrying about changing all of the built-in functionality.

CODE BLISS


If you've looked around or used any one of the many PHP Framework Systems that are available, one word

MVC -- MODELS


The Jet Engine, being completely "MVC" based relies quite heavily on the iSQL Database Abstraction Layer and Record Object system to manage the data "Models"

Within The Jet, a "Model" is a pointer to a database record. You create a new Record Object, and with that object, you can do all sorts of really important things -- show the user an input/edit form, save, update, or delete the record, or use its data to display somthing out on screen.

In most cases, unlike other MVC systems, you'll never need to create a model (in code form) for your data. The base Record object does probably 99% of what you need done within it's own methods. Combined with a database table schema, you can do everything. Should you need to extend the functionality of the base Record object, you may simply create an object that "extends" from Record in the "models" directory and write any necessary code you need in there. Generally speaking, though, the core objects to everything you need: Open, Edit (HTML Form), Save, Delete, Copy, Paste.

The Jet Engine uses the iSQL Database Record system, which allows you to very easily work with SQL table data. Part of the magic behind that system is the "Database Table Schemas", which allow you fine-tune your SQL Tables. For each table, you define not only the type of data (integer, etc), but the form prompts to use, the type of input (text box, select, radio, etc), allowed values, etc. Once you setup your table schema, all of the input forms that reference that table will use these settings to create the form the way you want it, and will do all error checking based on your preferences.

When you want to edit a database record, it's as easy as creating a record object, calling the "generate_form()" method to show an HTML form, and then calling the "save()" method, which will validate all of the input and save the information to the DB for you.

MVC -- VIEWS


The "View" part of the MVC paradigm refers to the Look and Feel -- the actual HTML that makes up your program's output. Perhaps the most important piece of the MVC puzzle, the concept of Views essentially eliminates any and all HTML from your program's output and put's all of that into separately maintained templates.

This allows you, the programmer, to keep the logic and programming code completely separate (and not dependant upon) the design elements. The way that The Jet Engine accomplishes this, is through the iTemplate System

iTemplate is a truly "smart" templating system. We believe in the "zero logic" system of templating. Using simple tags (or "tokens") within your HTML template, the iTemlate system injects your program output into your html where you want it. It doesn't require you learn a new template language, or force you inject logic into your design (designers generally don't like to have to think, so why make them?). Simple. Clean. Smart.

Template are broken down into 2 types:

1. FULL PAGE Templates
   Allow you to define the look of the entire page (not just the header and footer) at once. Using our "Plugin" system to insert program output bits wherever you want them within the entire HTML document.
   
   
2. SUB TEMPLATES
   Allow you to design how each piece of your overall output (i.e. BLOG Posts, Survey Results, etc) will look. These are generally completely data driven.

Read More about the iTemplate System ...

MVC -- CONTROLLERS


Controllers are where the programmers live ... in The Jet Engine, a controller *is* your application. The conroller is the piece of the MVC puzzle that does the thinking and then combines the Models with the Views to create some sort of output (usefulness) for your application.

To use a blog as a simple example, your controller is called "blog". The Jet Engine automatically keys itself on the word/position "action", and matches that to internal functions, with "index" being the default. So, let's assume any of the following URLs:

• http://www.domain.com/index.php?controller=blog
• http://www.domain.com/index.php?controller=blog&action=index
• http://www.domain.com/blog/
• http://www.domain.com/blog/index/

The Jet Engine knows to use the "blog" application, and knows that it has to run the "index" function (even when it's not specified, it's the default), so it looks in the /applications/blog/ directory for the controller file (application.php), runs the "index()" method, and then replaces <-- PLUGIN:BODY --> in the template (view) with whatever output the index() function generates. In the case of the blog, this might be snippets from the last 4 posts. To create the snippets, your index() method probably does an SQL lookup to find them, and uses sub templates (views) to merge the data from the database into the HTML that the sub-template defines, and then returns it.

As a programmer, all you needed to do was create an index() method that does an SQL lookup, and "foreach()" record that it found, merge() the data with a template, and return that output --- all of the functionality to do the lookup and merge with the subtemplates is built into the system, all you need to do is call the methods.

Again, the idea here is to get you out of the design business and back into the thinking business. This also lets someone decide in a few months that they want to completely change the look of the system. Fine. Let them open up the admin program and put new HTML into the templates. Your code forever remains completely unchanged (unless you need to add/change functionality).