Mukesh Chapagain's Blog » Smarty

File Upload in PEAR and Smarty

Mukesh — Mon, 21 Jul 2008 10:07:18 +0000

For uploading files, you need to install a package of PEAR called ‘HTTP_Upload’ along with the installation of PEAR and Smarty.

HTTP_Upload is used for easy and secure managment of files submitted via HTML forms. This package provides an advanced system for managing uploads of files via HTML
fields. Features include:

1) Handling of multiple file uploads at a time

2) Safe file copying/moving from temporary directories

3) Upload validaton mechanisms

4) Extensive information about uploaded files

5) Renaming uploaded files

6) Internationalized error messages

Two class files are included in index.php. One is ConnectSmarty.class.php which is used for connecting with Smarty. I have explained about it in my previous article. The other is files.class.php.

files.class.php


class Files
{
function upload($field_name,$dest)
{
$upload =& new HTTP_Upload("en");
$file = $upload->getFiles($field_name);
if ($file->isValid())
{
$moved = $file->moveTo("$dest/");
if (PEAR::isError($moved))
{
require_once('ConnectSmarty.class.php');
// create an object of the class included above
$smarty = new ConnectSmarty;
$error =& $moved->getMessage();
// assign error message
$smarty->assign('errmessage',$error);

// display error message and exit
$smarty->display('error.tpl');
exit();
}
}
}
}
?>

This class file includes the upload class which becomes available after installing the HTTP_Upload package. I have created a function named ‘upload’ inside the class ‘Files’. The upload() function requires two parameters: $field_name and $dest.

$field_name is the name of input file.

$dest is the name of the destination directory where the file is to be uploaded.

The function getFiles() checks if a valid file was uploaded through the form. If the file is valid then it is moved to the destination directory.

If there is error while moving the file to the destination directory then the error message is fetched through the getMessage() function and displayed in a separate template file called error.tpl.

index.php


// create an object of the class included above
$smarty = new ConnectSmarty;
if(isset($_POST['submit']))
{
$post = $_POST;
$keys = "";
$type = $_FILES['logo']['type'];
// Only allowing jpeg and gif image to be uploaded
if($type == "image/jpeg" || $type == "image/gif")
{
/**
* file upload part
* creating an object of the class Files
* calling the upload function of the class Files
* the destination directory is to be created at first
* in this case, the destination directory is created and named 'uploads'
*/
$file =& new Files;
$fieldName = "logo";
$dest = "uploads";
$file->upload($fieldName,$dest);

// assign success message
$smarty->assign('success','File Uploaded Successfully');
}
else
{
// assign error message
$smarty->assign('error','Only jpge and gif image are supported.');

// display error message and exit
$smarty->display('index.tpl');
exit();
}
}

// display the content
$smarty->display('index.tpl');

?>

I have only allowed jpeg and gif image to be uploaded. If the file is successfully uploaded then a success message is assigned and displayed.

// assign success message

$smarty->assign('success','File Uploaded Successfully');

If the file is not of jpeg or gif type then an error message is assigned and displayed.

// assign error message

$smarty->assign('error','Only jpge and gif image are supported.');

// display error message and exit

$smarty->display('index.tpl');

exit();

index.tpl




 Homepage : File Upload




{$success}
{$error}

Upload Logo


Logo

error.tpl



{$errmessage}

Download source code

Note: I have not included Smarty library files in this zip file. You can download the Smarty library files from http://smarty.php.net/download.php or directly from http://chapagain.googlecode.com/files/smarty.zip

From Mukesh Chapagain's Blog | Post File Upload in PEAR and Smarty

Copyright © 2010
This feed is for personal, non-commercial use only.
The use of this feed on other websites breaches copyright. If this content is not in your news reader, it makes the page you are viewing an infringement of the copyright. (Digital Fingerprint:
)

Related posts:

Pagination in PEAR and Smarty

Mukesh — Sun, 20 Jul 2008 10:20:53 +0000

First of all, you need to install PEAR in your web server. Then you need to install Smarty. After that, you need to install a package in PEAR. It’s called ‘Pager’.

Pager is a class to page an array of data. It is taken as input and it is paged according to various parameters. Pager also builds links within a specified range, and allows complete customization of the output.

In the index.php file, we make a function named getPager(). This function contains four parameters – $item, $perPage, $mode, and $delta.

$item is the array of data.

$perPage is the number of data to be displayed per page.

$mode defines about the mode of pagination links. There are two types of modes – Sliding and Jumping. The Jumping mode displays ‘Back’ and ‘Next’ link.

$delta defines the width of pagination links. High value of $delta increases the width of pagination links.

The getPager() function returns an array of data and links. The first element of the array contains array of data and the second element contains pagination links.

index.php


// create an object of the class included above
$smarty = new ConnectSmarty;
function getPager($item,$perPage,$mode,$delta)
{
// setting Sliding as default mode
if($mode == "")
{
$mode = 'Sliding';
}

// setting the default delta value as 2
// delta means the width of pagination
// more delta value results more width
if($delta == "")
{
$delta = '2';
}

$params = array(
'mode'=>$mode,
'perPage'=>$perPage,
'delta'=>$delta,
'itemData'=>$item);
$pager =& Pager::factory($params);
$data = $pager->getPageData();
$links = $pager->getLinks();
$links = $pager->links;
return array($data,$links);
}

$mode = 'Sliding'; // $mode = 'Jumping';
$perPage = '3';
$delta = '2';
$item = array(
array('country_id'=>'1','country_name'=>'India'),
array('country_id'=>'2','country_name'=>'Pakistan'),
array('country_id'=>'3','country_name'=>'Nepal'),
array('country_id'=>'4','country_name'=>'Srilanka'),
array('country_id'=>'5','country_name'=>'Bangladesh'),
array('country_id'=>'6','country_name'=>'Maldives'),
array('country_id'=>'7','country_name'=>'Bhutan'),
array('country_id'=>'8','country_name'=>'Afganistan'),
array('country_id'=>'9','country_name'=>'China')
);
$pagination = getPager($item,$perPage,$mode,$delta);
// print_r($pagination);

$smarty->assign('pager',$pagination[1]);
$smarty->assign('country',$pagination['0']);

// display the content
$smarty->display('index.tpl');

?>

foreach loop is used to display data. Before trying foreach loop, I had tried section loop but it didn’t work with pagination/pager. After that I tried the foreach loop and it worked fine and smooth. J

A custom Smarty function ‘cycle’ is used to alternate row color of the table on which data is being displayed. Cycle is used to cycle through a set of values. This makes it easy to alternate between two or more colors in a table, or cycle through an array of values.

index.tpl



 Homepage : Pagination





{foreach from=$country item=view}

{/foreach}



Country ID Country Name

{$view.country_id}
{$view.country_name}
{$pager}

Download source code

From Mukesh Chapagain's Blog | Post Pagination in PEAR and Smarty

Related posts:

Using database in PEAR and Smarty

Mukesh — Fri, 18 Jul 2008 06:00:57 +0000

For using database, you need to install a package of PEAR called ‘MDB2’ along with the installation of PEAR and Smarty.

MDB2 provides a common API for all support RDBMS.

Connecting to database

To connect to a database through PEAR::MDB2, you have to create a valid DSN – data source name. This DSN consists in the following parts:

phptype: Database backend used in PHP (i.e. mysql , pgsql etc.)

dbsyntax: Database used with regards to SQL syntax etc.

protocol: Communication protocol to use ( i.e. tcp, unix etc.)

hostspec: Host specification (hostname[:port])

database: Database to use on the DBMS server

username: User name for login

password: Password for login

proto_opts: Maybe used with protocol

option: Additional connection options in URI query string format. options get separated by &.

The DSN can either be provided as an associative array or as a string. The string format of the supplied DSN is in its fullest form:

phptype(dbsyntax)://username:password@protocol+hostspec/database?option=value

To instantiate a database object you have several methods available using MDB2.

factory() : Will instantiate a new MDB2_Driver_Common instance, but will not connect to the database until required. This will delay making the actual connection.

connect() : Will instantiate a new MDB2_Driver_Common instance, and will establish a database connection immediately. This way any connection issues will immediately raise an error.

singleton() : Returns a MDB2_Driver_Common instance.

A new MDB2_Driver_Common object is only created once using factory(), subsequent calls to singleton will return a reference to the existing object. This method is preferred over declaring your database object as a global.

To connect to a database you have to use the function factory(), connect() or singleton(), which require a valid DSN as the first parameter. This parameter can either be a string or an array. The second parameter is the optional $options array that can contain runtime configuration settings for this package.

I have used the connect() function with the DSN as

phptype://username:password@hostspec/database

$mdb2 =& MDB2::connect('mysql://root:@localhost/test');

In my case, the database backend is mysql, database username is root, database password is null, the hostname is localhost and the database name is test.

Querying the database

PEAR MDB2 provides several methods for querying databases. The most direct method is query(). It takes a SQL query string as an argument. There are two possible returns: A new MDB2_Result object for queries that return results (such as SELECT queries), or a MDB2_Error object on failure. It should not be used with statements that manipulate data (such as INSERT queries).

exec() should be used for manipulation queries. There are two possible returns: An integer denoting the number of affected rows for statements that manipulate data (such as INSERT queries), or a MDB2_Error object on failure. It should not be used with statements that return results (such as SELECT queries).

Here, I will only be dealing with the SELECT queries.

$mdb2 = new ConnectMDB2;
// calling the function conMDB2 of ConnectMDB2 class
$connect = $mdb2->conMDB2();
$res = $connect->query("SELECT * FROM basic");

Fetching result

The MDB2_Result_Common object provides four methods for fetching data from rows of a result set: fetchOne(), fetchRow(), fetchCol() and fetchAll().

fetchRow() and fetchOne() read an entire row or a single field from a column respectively. The result pointer gets moved to the next row each time these methods are called. NULL is returned when the end of the result set is reached.

fetchAll() and fetchCol() read all rows in the result set and therefore move the result pointer to the end. While fetchAll() reads the entire row data, fetchCol() only reads a single column.

MDB2_Error is returned if an error is encountered.

I have used the fetchRow() method. The fetchmode MDB2_FETCHMODE_ASSOC is used for fetching data. The default fetchmode is MDB2_FETCHMODE_ORDERED.

while($row[] = $res->fetchRow(MDB2_FETCHMODE_ASSOC))
{
$result = $row;
}

If there is any error then the error message is displayed in a separate template called error.tpl. And if there is no error while fetching data then the fetched result is displayed in the template file index.tpl.

if(PEAR::isError($res))
{
// get error message
$error =& $res->getMessage();
// assign error message
$smarty->assign('errmessage',$error);
// display the message and exit
$smarty->display('error.tpl');
exit();
}
// asign the content
$smarty->assign('result',$result);

// display the content
$smarty->display('index.tpl');

In the template file, foreach loop is used to display the result.

{foreach from=$result item=view}

{$view.firstname}
{$view.lastname}

{/foreach}

Download source code

From Mukesh Chapagain's Blog | Post Using database in PEAR and Smarty

Related posts:

Creating selection list, using foreach and section loop in Smarty

Mukesh — Wed, 16 Jul 2008 06:56:29 +0000

In this article, I will be illustrating and explaining about foreach and section loop used in Smarty. I will be using these loops for creating a selection list.

We can create selection list from a custom Smarty function called ‘html_options’. html_options is a custom function that creates html option group with provided data. It takes care of which item(s) are selected by default as well. Required attributes are values and output, unless you use options instead.

Instead of html_options, we can also use loops to create the selection list. There are namely two loops in Smarty: 1) Section, and 2) Foreach

1) Template sections are used for looping over arrays of data. All section tags must be paired with /section tags. Required parameters are name and loop. The name of the section can be anything you like, made up of letters, numbers and underscores. Sections can be nested, and the nested section names must be unique from each other. The loop variable (usually an array of values) determines the number of times the section will loop. sectionelse is executed when there are no values in the loop variable.

2) foreach loops are an alternative to section loops. foreach is used to loop over a single associative array. The syntax for foreach is much easier than section, but as a tradeoff it can only be used for a single array. foreach tags must be paired with /foreach tags. Required parameters are from and item. foreach loops can be nested, and the nested foreach names must be unique from each other. The from variable (usually an array of values) determines the number of times foreach will loop. foreachelse is executed when there are no values in the from variable.

Download source code

Thank You.

From Mukesh Chapagain's Blog | Post Creating selection list, using foreach and section loop in Smarty

Related posts:

Templating in Smarty

Mukesh — Mon, 14 Jul 2008 08:35:19 +0000

You can also include other smarty template files in one smarty template. This brings the use of template function available in Smarty.

You may want to make a constant header and footer for your entire website. For this purpose, you can use the ‘include’ tag. Include tags are used for including other templates in the current template. Any variables available in the current template are also available within the included template. The include tag must have the attribute “file”, which contains the template resource path.

You can also pass variables to included templates as attributes. Attribute variables override current template variables. In our case, the ‘title’ variable is passed to the included template ‘header.tpl’. It the ‘title’ variable is not passed in the included template ‘header.tpl’ then the default value of the title assigned in ‘header.tpl’ will be printed.

We have included header.tpl and footer.tpl in the index.tpl file. The header.tpl file contains title and banner text. The footer.tpl file contains copyright information. This information is constant over the entire website. So, it would be easy to modify the header and footer content if we include these files in every individual template.

index.tpl

{include file="header.tpl" title="Homepage"}
The author of this tutorial:


Name: {$name} 

Address: {$address} 

Date: {$smarty.now|date_format:"%Y-%m-%d"} 

{include file="footer.tpl"}

header.tpl


 {$title|default:"no title"} 



Welcome to my site

footer.tpl

Download source code

From Mukesh Chapagain's Blog | Post Templating in Smarty

Related posts:

Installing the Smarty Template Engine

Mukesh — Fri, 11 Jul 2008 12:19:45 +0000

At first you need to download Smarty from http://smarty.php.net/download.php or you can download it directly from http://chapagain.googlecode.com/files/smarty.zip. Extract the zip file. Rename the extracted folder as ‘smarty’. Then, copy the folder ‘smarty’ to your working directory present inside the root directory of your web server.

There are different ways to install Smarty.

1) You can simply supply the absolute path to the Smarty library file:-

require(‘/usr/local/lib/php/Smarty/Smarty.class.php’);

2) You can add library directory to PHP include_path

Copy the libs folder from the Smarty distribution to the mycode folder (for example, C:\apache\htdocs\mycode\libs\).

After this, you need to edit the php.ini file and add include_path = “.;C:\apache\htdocs\ mycode\libs\” where C:\apache\htdocs\mycode\libs\ represents the location of your libs folder.

3) You can set SMARTY_DIR constant manually

define(‘SMARTY_DIR’, ‘/usr/local/lib/php/Smarty/’);

require(SMARTY_DIR . ‘Smarty.class.php’);

4) A slightly more flexible way to setup Smarty is to extend the class and initialize your Smarty environment. So instead of repeatedly setting directory paths, assigning the same vars, etc., we can do that in one place.

I will be explaining the fourth way, i.e. extending the class and initializing Smarty environment.

At first, let us have a look on the directory structure that we must create. Suppose, our work folder is named ‘example’, then our directory structure should be as under:-

example

|_ _ _ _ _ _ _ smarty (this directory contains Smarty library files)

|_ _ _ _ _ _ _ classes (this directory contains class files that we create)

|_ _ _ _ _ _ _ smarty_temp (contains manually created Smarty directories)

|_ _ _ _ _ _ _ index.php

As stated at the beginning of this article, the Smarty library files are kept in the ‘smarty’ directory.

Smarty requires four directories which are (by default) named templates, templates_c, configs and cache. Each of these are definable by the Smarty class properties $template_dir, $compile_dir, $config_dir, and $cache_dir respectively. It is highly recommended that you setup a separate set of these directories for each application that will use Smarty. We create these directories inside ‘smarty_temp’ directory.

Now, let’s move to the class file which is kept inside the classes directory.



/**
* Connection to Smarty package
*
*/

class ConnectSmarty extends Smarty
{
/**
* This function connects with smarty
* manage paths to smarty directories
* @access public
*/
function ConnectSmarty()
{
$this->Smarty();

$this->template_dir = 'smarty_temp/templates';
$this->config_dir = 'smarty_temp/configs';
$this->cache_dir = 'smarty_temp/cache';
$this->compile_dir = 'smarty_temp/templates_c';
}
}

?>

The above class is called in the index page. An object of the class is created. Then, the Smarty method called ‘assign’ is used to assign values to the template. Through assign method, you can explicitly pass name/value pairs, or associative arrays containing the name/value pairs. After that ‘display’ method is used to display the template.

assign('name','Mukesh Chapagain');
$smarty->assign('address','Kathmandu, Nepal');

// display the content
$smarty->display('index.tpl');

?>

index.tpl is the template file which contains html and smarty code.



 Homepage 




The author of this tutorial:


Name: {$name} 

Address: {$address}

Download source code

Thank You.

From Mukesh Chapagain's Blog | Post Installing the Smarty Template Engine

Related posts:

An Introduction to Smarty Template Engine

Mukesh — Sun, 29 Jun 2008 05:32:30 +0000

Smarty is a template engine for PHP. More specifically, it facilitates a manageable way to separate application logic and content from its presentation. This is best described in a situation where the application programmer and the template designer play different roles, or in most cases is not the same person.

One day the programmer needs to change the way the article content is retrieved (a change in application logic.) This change does not affect the template designer, the content will still arrive in the template exactly the same. Likewise, if the template designer wants to completely redesign the templates, this requires no changes to the application logic. Therefore, the programmer can make changes to the application logic without the need to restructure templates, and the template designer can make changes to templates without breaking application logic.

One design goal of Smarty is the separation of business logic and presentation logic. This means templates can certainly contain logic under the condition that it is for presentation only. Things such as including other templates, altering table row colors, upper-casing a variable, looping over an array of data and displaying it, etc. are all examples of presentation logic. This does not mean that Smarty forces a separation of business and presentation logic. Smarty has no knowledge of which is which, so placing business logic in the template is your own doing. Also, if you desire no logic in your templates you certainly can do so by boiling the content down to text and variables only.

With Smarty, the PHP syntax doesn’t contain print. Instead, the programmer passes these arrays to the designer by assigning them to Smarty templates. Then it’s the designer’s job to make them look good in the web page without worrying about the PHP code. The use of Smarty comes at its best when you have different programmers and designers and you don’t want the designer to access the system core.

Smarty makes the job of the designer as well as the programmer very easy. The key tasks performed by them can be listed as follows.

The Programmer’s tasks:

• Extract database elements with a simple query on the database.

• Validate and manipulate the data by performing business logic on it.

• If needed, change the data access methods and the business logic without interfering with the designer’s work. For example, the whole system could migrate from MySQL to PostgreSQL without the designer making a single change.

The Designer’s tasks:

• Create HTML designs without affecting or jeopardizing the programmers PHP code. The designer only needs to be concerned with placing the content elements that the programmer has agreed to provide.

• Make changes to the design without consulting or interfering with the programmer’s work.

• Stop worrying about technical changes to the site breaking the way that the site appears to viewers.

Some of the Smarty Features are:-

No template parsing overhead, only compiles once. It is smart about recompiling only the template files that have changed.

One of the unique aspects about Smarty is the template compiling. This means Smarty reads the template files and creates PHP scripts from them. Once they are created, they are executed from then on. When a file is called from the web, the php file is parsed and smarty compiles the results from the template files used. When that same page is called and the template files have not been altered smarty will use the compiled version which causes the server to not need to recompile the pages.

Built-in caching support

Smarty has the ability to use cache. Hence, it is extremely fast. Smarty caches the output of the template contents, saving the overhead expense involved in retrieving data from a data source. Smarty caches the output of the template with this data from the data source, and saves you from having to connect to the database every time your Web page is accessed.

Smarty is again smart enough to allow you to specify what should or should not be cached. In fact, you can have cached and un-cached portions on the same template page, as Smarty allows you to specify exactly what you don’t want cached (like that stock ticker at the bottom of the page, which is frequently changed) and what you do want cached (such as your navigation bar, which is seldom changed). You can also set the cache expiry time so that your template output is cached only for a specific length of time. You can thus achieve the middle-ground between having up-to-date dynamic content and quick-to-load Web pages.

You can make custom functions and custom variable modifiers, so the template language is extremely extensible.

Smarty provides built-in and custom functions for use in your templates. These functions are like the API of Smarty templates, except that custom functions can be modified but not built-in functions. In the custom functions, you can assign template variables during the execution of the templates.

Variable modifiers give template designers the ability to modify template variables. Variable modifiers can be applied to variables, custom functions or strings. To apply a modifier, specify the value followed by the | (pipe) and the modifier name. A modifier may accept additional parameters that affect its behavior. These parameters follow the modifer name and are separated by : (colon).

{$title|upper} = Applying modifier to a variable. This will change the variable text into uppercase.

{$title|truncate:40:”…”} = Applying modifier with parameters. This will truncate the variable text into 40 characters followed by three dots (…).

It is possible to embed PHP code right in your template files, although this may not be needed (nor recommended) since the engine is so customizable.

php tags allow php to be embedded directly into the template. This is for advanced users only, not normally needed.

{php}

// including a php script directly

// from the template.

include(“/path/to/display_weather.php”);

{/php}

Presence of conditional statements (if/elseif/else) and loops (foreach/section)

{if} statements in Smarty have much the same flexibility as PHP if statements, with a few added features for the template engine. Every {if} must be paired with an {/if}. {else} and {elseif} are also permitted. All PHP conditionals are recognized, such as ||, or, &&, and, etc.

{if $name eq “Fred”}

Welcome Sir.

{elseif $name eq “Wilma”}

Welcome Ma’am.

{else}

Welcome, whatever you are.

{/if}

Template sections are used for looping over arrays of data. All section tags must be paired with /section tags. foreach loops are an alternative to section loops. foreach is used to loop over a single associative array. foreach tags must be paired with /foreach tags. Both section and foreach loops can be nested, and the nested loops names must be unique from each other.

Config Files

Config files are configuration files where you can store global template variables. This allows you to store variables that should affect every template (i.e. global variables) in a central location. A good example of such a variable would be the color scheme for your templates. Normally if you wanted to change the color scheme of an application, you would have to go through each and every template file and change the colors. With a config file, the colors can be kept in one place, and only one file needs to be updated.

The other variables that you can store in a config files are like page title, page information, database information, etc.

Plugin architecture

The Smarty plug-in architecture was introduced in version 2.0 and allows you to customize Smarty to suit your purposes. With plug-ins, you can create your own template functions, variable modifiers and filters. It is used for almost all the customizable functionality of Smarty. This includes: functions, modifiers, block functions, compiler functions, prefilters, postfilters, outputfilters, resources, and inserts.

Source:

1) Smarty Manual, Monte Ohrt, Andrei Zmievski, 2001-2005 New Digital Group, Inc.

2) Smarty – PHP Template Programming and Applications, Lucian Gheorghe, Hasin Hayder, Joao Prado Maia.

3) http://www.sitepoint.com/article/smarty-php-template-engine

From Mukesh Chapagain's Blog | Post An Introduction to Smarty Template Engine

Related posts:

Country ID	Country Name
{$view.country_id}	{$view.country_name}
{$pager}