You should add a new position in admin/controller/slideshow.php

$this->data['text_header'] = $this->language->get('text_header'); 

Then do this in admin/language/slideshow.php

$_['text_header']   = 'Header'; // in admin/language/slideshow.php

Now go to admin/view/slideshow.tpl

<?php 

if ($module['position'] == 'header') { ?> 

<option value="header" selected="selected"><?php echo $text_header; ?></option>

<?php } else { ?>

<option value="header"><?php echo $text_header; ?></option>

<?php } ?>

A new position for slideshow has been defined. and you can choose it in the admin panel now.

add the following code to catalog/view/header.tpl

 <?php foreach ($modules as $module) { ?>

<?php echo $module; ?>

<?php } ?>

In the catalog/controller/header.php, add some codes like content_top.php does: $layout_id = 1;

$module_data = array();
$this->load->model('setting/extension');
$extensions = $this->model_setting_extension->getExtensions('module'); 
foreach ($extensions as $extension) {

  $modules = $this->config->get($extension['code'] . '_module');
 if ($modules) {

  foreach ($modules as $module) {

  if ($module['layout_id'] == $layout_id &&
      $module['position'] == 'header' && $module['status']) {

  $module_data[] = array(

  'code'       => $extension['code'],

  'setting'    => $module,

  'sort_order' => $module['sort_order']

  ); 

  }

  }

  }

  }
$sort_order = array(); 
foreach ($module_data as $key => $value) {

  $sort_order[$key] = $value['sort_order'];

  }
array_multisort($sort_order, SORT_ASC, $module_data);
$this->data['modules'] = array();
foreach ($module_data as $module) {

  $module = $this->getChild('module/' . $module['code'], $module['setting']);
 if ($module) {

  $this->data['modules'][] = $module;

  }

  }


if (file_exists(DIR_TEMPLATE . $this->config->get('config_template') . '/template/common/header.tpl')) {

  $this->template = $this->config->get('config_template') . '/template/common/header.tpl';

  } else {

  $this->template = 'default/template/common/header.tpl';

  }
$this->render();

Finally, add the following code to the header template for your theme

    <script type="text/javascript" src="catalog/view/javascript/jquery/nivo-slider/jquery.nivo.slider.pack.js"></script>

<link rel="stylesheet" type="text/css" href="catalog/view/theme/default/stylesheet/slideshow.css" media="screen" />

Your site should be working … thanks for reading.

1. You can go into the information section using the admin area.

2. You can create a controller file for your page, which points to a few other pages.

In codeigniter you would create a controller and a view and if setup was needed, we would create some rules in the routes file. This application is just a bit different.
Thankfully, this is a really simple task in OpenCart web Development.

How to create a custom page in OpenCart:

You need to create a controller for your file, naming based on the folder and filename. For instance common/home.php Has the class initialization like this :

Class ControllerCommonHome extends Controller

This is accessed using index.php?route=common/home and accesses the index() method.
If you want to call another method, for instance bananas, you would need to define the method as

public function bananas() {
    // Code here
}

and we would call it using index.php?route=common/home/bananas.
Now, we need to render the view. Simply add all of the following code to the end of your controller method :

 if (file_exists(DIR_TEMPLATE . $this->config->get('config_template') .
     '/template/common/new_template_file.tpl')) {

        $this->template = $this->config->get('config_template') .
        '/template/common/new_template_file.tpl';
    } else {
        $this->template = 'default/template/common/new_template_file.tpl';
    }

    $this->children = array(
        'common/column_left',
        'common/column_right',
        'common/content_top',
        'common/content_bottom',
        'common/footer',
        'common/header'
    );

    $this->response->setOutput($this->render());

Which will render the following :

 /catalog/view/theme/your-theme-name/template/common/new_template_file.tpl 

If that file doesn’t exist, it will attempt to use the same path in the default theme folder.

Take a look at a few controllers and templates to get your head around where everything comes from properly, but that’s the basic gist of how creating a custom page in OpenCart works.

We hope that you have enjoyed our short post in OpenCart Web Development. Stay tuned …

WordPress shows the version number in the meta generator tag by default. IT is probably best practices to remove it for security reasons. This is very simple to do in wordpress, just add a line of code within the functions.php file in the root of your theme.

To remove meta generator tag in wordpress, follow the steps below:

It goes like this :

f you do not have functions.php file, you may create one with the content below and upload to your theme folder:

Then type the following :

Done, you have just removed meta generator tag in wordpress
Now clear your wordpress cache (if you have any) and visit the source of the front page to verify the existence of meta generator tag.

Keyword density is a combination of the number of times a keyword or a keyword phrase, in proportion with other words, appears on a Web page. The more times the keyword appears in relation to the total number of on page words, the greater the overall keyword density. The more times that other words appear, the lower the proportion of keywords, resulting in a lighter keyword density.

Does keyword density make a difference?

The various search engines, including Google, Yahoo, and MSN Search consider keyword density as part of their search algorithm. Each search engine has a different mathematical equation regarding the density of keywords that is rewarded with higher search ranking placement. There is also a different level of tolerance between the different search engines as to the degree of density permitted before a penalty is imposed.

Okay, so what are keywords anyway?

Keywords are the terms that searchers enter into the search engine’s search interface when seeking information, products, or services. The keyword is entered into the search engine algorithm as a mathematical calculation, to determine relevance of the many billions of Internet pages to that particular search. The pages the algorithm deems most relevant to the search for those keywords are ranked accordingly.

How are keywords different from keyword phrases?

A keyword can be one single word or a phrase including that word. Searchers use both types of entries when seeking information. As a general rule, the longer the phrase, the more specific the returned information will be from the search engine index.

Different search engines treat keyword density differently?

It’s generally thought by search engine optimization experts that Yahoo and MSN Search tolerate heavier keyword densities per page than industry leader Google. As with all areas of SEO, there is some debate on this issue, and counter examples are very likely to be found. Generally, however, Google is less tolerant of heavy keyword usage than Yahoo or MSN.

Is there a formula for keyword density?

There is no hard and fast formula for keywords but it’s probably best to keep the keyword percentage below five percent of the total number of words on the page. Any more words could potentially trigger a keyword stuffing filter. Too many keywords in any on page copy can also work against the page’s readership retention and its conversion rate from visitor to paying customer. After all, the purpose of a Web page, for any commercial website, is to convert visitors to customers. For an informational website, the goal is to have as many visitors as possible read the available information. Badly written copy precludes those things from happening.

Is keyword density different from keyword placement?

Keyword density refers to the amount of keywords used on the page, in relation to the total number of words on the page in question. Keyword placement refers to the location of the words on a Web page. That placement could be in the title tags, links, headings, main body of copy, or anywhere else where wording appears on a Web page.

Does the order of keywords make a difference?

Some SEO experts believe that placing keywords higher on the page gives that page a boost in the search rankings. That opinion is not shared by all search engine observers, however. In general, it’s better to sprinkle the keywords throughout the on page copy in a normal writing fashion. Natural sounding content is much easier to read, and could even score as well in the search rankings as any special placements on the page.

Can keywords help as link anchor text?

Link anchor text is a common usage of keywords and has little effect on keyword density of the sending or receiving page. For purposes of SEO, link anchor text, comprised of the receiving page’s most important keywords, is probably more powerful than heavier use of keywords in on page copy. Keywords in link anchor text tell the search engines what the receiving page is about in terms of themes and topics. A form of keyword stuffing, that appears unnatural to the search engines, is the use of exactly the same keywords in all incoming link anchor text. Keywords and phrases are best mixed and matched, with several variations of link anchor text employed.

Are keywords important in title tags?

The use of keywords in title tags is a powerful placement of the page’s most important search terms. In title tags, the placement of keywords is important. The most important keywords should be placed at the beginning of the page title tag. As with all keywords, there is danger of keyword stuffing in the title tags themselves. Be sure to refrain from using any word more than three times in the title tag. A maximum of twice would be even safer to prevent triggering a keyword stuffing filter.

Does the keyword form make a difference?

Keywords can be written as planned for the search engines. They can also be organized into desirable search phrases. Plural and singular forms of the words should also be utilized as many searchers will choose either one form or the other. Additional ways of writing keywords include adding -ed, -ing, or other related suffixes to reflect different searches.
Plural and singular forms of a keyword will often result in vastly different search results in Google, making it important that both forms of a keyword be part of the copy if well written content is the result. If different word variations become too difficult, and if the keyword is highly competitive, it’s preferable to create an entirely new page for each alternative form of the word, to concentrate the keyword power of the page.

Should different keywords be used in the on page copy?

It’s a good idea to use different keywords on the Web page. By doing so, the page could rank well for other searches, many of which might result in more traffic or sales than the originally targeted keyword or phrase. The different words also make the page more pleasant for visitors to read, greatly enhancing the site’s length of stays and sales conversion rates. In highly competitive situations, however, the best course of action is often to create separate Web pages for each different keyword or phrase.

What is the best way to write on page copy?

The best way to write Web page copy is in an easy to read format. The copy should flow freely, and lead the visitor either to convert to a customer, or to seek even more information from the website. Placing the sought after keywords in natural locations throughout the information, in the page headings, and title tags will enhance the page’s keyword value. It will also prevent keyword stuffing possibilities as the keywords are not all packed into the page’s informational or sales copy.

Are there any tools for calculating keyword density?

A number of good keyword density tools are available. They include:
Search Engine World’s Keyword Density Analyzer http://www.searchengineworld.com/cgi_bin/kwda.cgi,

Keyword Density Analyzer http://www.virtualpromote.com/tools/keyword_analyzer/,

and SEO Chat’s SEO Tools – Keyword Density http://www.seochat.com/seo_tools/keyword_density/

There are many more good tools available with a simple search.

Can a Web page have too many keywords?

In theory, a web page can have an almost unlimited numbers of keywords provided that the page contains enough other words to balance them. In practice, however, a page should most certainly contain five percent keywords or fewer. The reason for restricting the number of keywords is not strictly to avoid Google filters. It’s also to keep the copy easily readable for the visitors. Badly written copy is not informative or good sales or marketing material. Any minimal benefit derived from slightly higher search rankings is more than offset by a rapid loss of visitor traffic and potential customers.

What is keyword stuffing?

Keyword stuffing is the very intensive placement of keywords within a Web page’s copy. In general, the level of keywords would be so frequent as to overwhelm the rest of the copy. While the overuse of keywords is likely to trigger a Google filter, the potential loss of visitor traffic due to hard to read content is a much larger problem. A searcher finding a Web page consisting of keywords obviously jammed in everywhere is highly unlikely to remain and convert to a paying customer. The loss due to keyword stuffing is therefore twofold.

What are some common forms of keyword stuffing?

Keyword stuffing can result from jamming as many of the keywords into the page’s informational copy as possible. The copy reads like a string of keywords and little else. Another form of keyword stuffing is to pack the word or words as many times as possible into the page title tags. The search engines will often downgrade the page in the search rankings, or perhaps ignore the keywords entirely. Neither result is beneficial to the website. Keyword stuffed doorway pages or cloaked pages are not only examples of keyword overuse, but are also penalty causing items in their own right. The constant and complete usage of the same link anchor text for all inbound links can be considered a form of keyword stuffing as well.

Can a site be penalized for keyword stuffing?

A site can and will be penalized by the search engines for keyword stuffing. Google appears to be very sensitive to overuse of keywords on the page, as a filter will be triggered. Penalties ranging from a downgrade in the search results, to the loss of Google PageRank, to possibly being banned are options that the search engine giant could consider imposing on the site. As with all search engine optimization efforts, common sense and thinking of what benefits your site’s visitors is the best action for any website owner to use.

RedBonzai Developers, INC is a group of web application developers dedicated to serious web development in Houston, Tx. We are currently expanding our repertoire to CodeIgniter Applications. We will talk quite a bit about E-Commerce in times to come, but in particular we are using our PHP development skills to create a CodeIgniter Shopping Cart that will fully equip you to sell digital goods online.
This is a tutorial originally authored by Dan Harper, and we will be expanding on it a bit. The CodeIgniter Image above is credited to Nucleocide.

Getting Started

Download the latest CodeIgniter release to your server, and set up your MySQL database (I named it digitalgoods) with the following SQL queries:

CREATE TABLE `ci_sessions` (
  `session_id` varchar(40) NOT NULL DEFAULT '0',
  `ip_address` varchar(16) NOT NULL DEFAULT '0',
  `user_agent` varchar(50) NOT NULL,
  `last_activity` int(10) unsigned NOT NULL DEFAULT '0',
  `user_data` text NOT NULL,
  PRIMARY KEY (`session_id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;

CREATE TABLE `downloads` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `item_id` int(11) DEFAULT NULL,
  `purchase_id` int(11) DEFAULT NULL,
  `download_at` int(11) DEFAULT NULL,
  `ip_address` varchar(15) DEFAULT NULL,
  `user_agent` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;

CREATE TABLE `items` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `description` text,
  `price` decimal(10,2) DEFAULT NULL,
  `file_name` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;

CREATE TABLE `purchases` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `item_id` int(11) DEFAULT NULL,
  `key` varchar(255) DEFAULT NULL,
  `email` varchar(127) DEFAULT NULL,
  `active` tinyint(1) DEFAULT NULL,
  `purchased_at` int(11) DEFAULT NULL,
  `paypal_email` varchar(127) DEFAULT NULL,
  `paypal_txn_id` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;

INSERT INTO `items` (`id`,`name`,`description`,`price`,`file_name`)
VALUES
  (1, 'Unix and CHMOD', 'Vivamus id mollis quam. Morbi ac commodo nulla.', 19.99, 'UNIX and CHMOD.txt'),
  (2, 'Intro to 8086 Programming', 'Morbi ac commodo nulla.', 4.95, 'Intro to 8086 Programming.txt');

The first query creates CodeIgniter’s default user sessions table. We then create a table to log file downloads, one to store the items and another to store purchase details. Finally, we insert a couple of items into the table.

We’ve inserted two items into the database, so we have to create those files on the server. In the root directory for your application (the same folder as CodeIgniter’s system directory), create a new directory named files:

In that directory, create two text files, named UNIX and CHMOD.txt and Intro to 8086 Programming.txt. The capital letters are important on most web servers. These are the file names we set in the database for our two items. Enter some content in the files so we can be sure the files are being downloaded correctly.

CodeIgniter Configuration

In the system/application/config/database.php file, set your database settings in the fields provided:

In config/autoload.php set the following libraries and helpers:

$autoload['libraries'] = array( 'database', 'session', 'form_validation', 'email' );
...
$autoload['helper'] = array( 'url', 'form', 'download', 'file' );

In config/config.php set the base_url:

$config['base_url']	= "http://localhost/digitalgoods/";

In the same file, paste the following to create our own configuration settings:

/*
|--------------------------------------------------------------------------
| Website Name
|--------------------------------------------------------------------------
|
| Will be used on page title bars, in emails etc.
|
*/
$config['site_name'] = "Digital Goods";

/*
|--------------------------------------------------------------------------
| Admin Email
|--------------------------------------------------------------------------
|
| Used to send confirmations of purchases
|
*/
$config['admin_email'] = "dan@example.com";

/*
|--------------------------------------------------------------------------
| No-Reply Email
|--------------------------------------------------------------------------
|
| The 'No-Reply' address used to send out file downloads
|
*/
$config['no_reply_email'] = "noreply@example.com";

/*
|--------------------------------------------------------------------------
| PayPal Account
|--------------------------------------------------------------------------
|
| The email address PayPal payments should be made to
|
*/
$config['paypal_email'] = "paypal@example.com";

/*
|--------------------------------------------------------------------------
| Download Limit
|--------------------------------------------------------------------------
|
| How many times can an item be downloaded within a certain time frame?
|   eg. 4 downloads within 7 days
|
*/
$config['download_limit'] = array(
	'enable'	=> false,
	'downloads'	=> '4',
	'days'		=> '7'
);

Set each of the new config options to your desired settings, but keep ‘Download Limit’ disabled for now.

Finally, under config/routes.php set the default controller:

$route['default_controller'] = "items";

View All Items

Now to create the main controller for the site, create a file in the controllers directory named items.php, and inside enter:

<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');

class Items extends Controller {

    function Items() {
        parent::Controller();
        $this->load->model( 'items_model', 'Item' );
        $data['site_name'] = $this->config->item( 'site_name' );
        $this->load->vars( $data );
    }

    function index() {
        echo 'Hello, World!';
    }

}

In the constructor we’ve loaded in the ‘items_model’ model (which we’ve named ‘Item’) which we’ll create next, and placed the ‘site_name’ configuration setting into a variable which we can access in the views. For the index method, we’ve just set a simple ‘Hello, World!’ message for now.

Also, create a new model by creating new file in the models directory named items_model.php and inside enter:

controllers/create a file named paypal.phpand enter the following inside:

<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');

class Paypal extends Controller {

  function Paypal() {
    parent::Controller();
    $this->load->model( 'items_model', 'Item' );
    $this->load->library( 'Paypal_Lib' );
    $data['site_name'] = $this->config->item( 'site_name' );
    $this->load->vars( $data );
  }

  function index() {
    redirect( 'items' );
  }

  function success() {
    $this->session->set_flashdata( 'success', 'Your payment is being processed now.
Your download link will be emailed to your shortly.' );
    redirect( 'items' );
  }

  function cancel() {
    $this->session->set_flashdata( 'success', 'Payment cancelled.' );
    redirect( 'items' );
    }

}

That’s the ‘success’ and ‘cancel’ pages (cancel is used with a user doesn’t continue with the payment and clicks the cancel button on PayPal instead).

PayPal Developer Tools

PayPal provide a ‘Sandbox’ for developers to test their code with. You can create your own sandbox PayPal addresses to send pretend payments. Sign up for a free developer account at https://developer.paypal.com/ then go to ‘Create a preconfigured buyer or seller account’:

Fill out the form to create a new buyer account, enter a balance and click on through. On the ‘Test Accounts’ page you will find the email address for your new Sandbox buyer email address:

Now go back to the site we’re creating and click through to purchase an item. Notice that when you get to PayPal, the address is https://www.sandbox.paypal.com/..... Login with the ‘buyer’ account you created on the right:

Continue through the payment process and click the ‘Return to Merchant’ button upon completion. You should be directed back to your homepage, with the “Your payment is being processed now. Your download link will be emailed to your shortly.” message below the header.

The main interface of the site is now complete. We just need to add in our IPN listener and email the item to the buyer.

IPN Listener

As mentioned above, once PayPal has confirmed payment, it will send data to our IPN listener, once we validate the data with PayPal (to prevent fraudulent data), we can use the data to activate the buyer’s purchase.

The IPN function is a little big, so I’ll break it up. Inside the PayPal controller, add the following function:

function ipn() {
  if ( $this->paypal_lib->validate_ipn() ) {
    $item_name = $this->paypal_lib->ipn_data['item_name'];
    $price = $this->paypal_lib->ipn_data['mc_gross'];
    $currency = $this->paypal_lib->ipn_data['mc_currency'];
    $payer_email = $this->paypal_lib->ipn_data['payer_email'];
    $txn_id = $this->paypal_lib->ipn_data['txn_id'];
    $key = $this->paypal_lib->ipn_data['transaction_subject'];

    $this->Item->confirm_payment( $key, $payer_email, $txn_id );
    $purchase = $this->Item->get_purchase_by_key( $key );
    $item = $this->Item->get( $purchase->item_id );
  }
}

Right at the start we validate the data sent to the listener with PayPal – the library takes care of all this. If the data is valid, we grab a some details (the item name, price, currency, the payer’s PayPal email address, the transaction ID and the unique key we sent to PayPal when the payment process began).

We can then use the key to confirm the payment (by setting the ‘active’ field to ’1′) and add the payer’s PayPal email and transaction ID to the database for future reference.

Using the key we can get the purchase details from the database, along with the item purchased. Before continuing with the IPN function, let’s create the confirm_payment() and get_purchase_by_key() model methods.

So inside the model, add the following:

function confirm_payment( $key, $paypal_email, $payment_txn_id ) {
  $data = array(
    'purchased_at'  => time(),
    'active'        => 1,
    'paypal_email'  => $paypal_email,
    'paypal_txn_id' => $paypal_txn_id
  );
  $this->db->where( 'key', $key );
  $this->db->update( 'purchases', $data );
}

function get_purchase_by_key( $key ) {
  $r = $this->db->where( 'key', $key )->get( 'purchases' )->result();
  if ( $r ) return $r[0];
  return false;
}

The functions should be pretty self explanatory by now, so now we need to email the customer their download link. This is handled in the IPN listender, so back in the controller add the following to the end of the ipn() function:

// Send download link to customer
$to = $purchase->email;
$from = $this->config->item( 'no_reply_email' );
$name = $this->config->item( 'site_name' );
$subject = $item->name . ' Download';

$segments = array( 'item', url_title( $item->name, 'dash', true ), $item->id );
$message = '<p>Thanks for purchasing ' . anchor( $segments, $item->name ) . ' from ' . anchor( '', $name ) . '.
Your download link is below.</p>';
$message .= '<p>' . anchor( 'download/' . $key ) . '</p>';

$this->email->from( $from, $name );
$this->email->to( $to );
$this->email->subject( $subject );
$this->email->message( $message );
$this->email->send();
$this->email->clear();

Here we’re using CodeIgniter’s Email class to send the email. We start by setting up ‘To’, ‘From’, ‘Name’ and ‘Subject’ variables with the relevant data.

We then write a short message for the body with a link to the file they purchased, followed by their download link (which will be in the format of: http://example.com/download/{key}). Finally we add the variables into the Email class methods and send it.

The final thing we need in the IPN listener is to send the site’s admin an email with the transaction details. Add the following to the end of the ipn() function:

// Send confirmation of purchase to admin
$message = '<p><strong>New Purchase:</strong></p><ul>';
$message .= '<li><strong>Item:</strong> ' . anchor( $segments, $item->name ) . '</li>';
$message .= '<li><strong>Price:</strong> $' . $item->price . '</li>';
$message .= '<li><strong>Email:</strong> ' . $purchase->email . '</li><li></li>';
$message .= '<li><strong>PayPal Email:</strong> ' . $payer_email . '</li>';
$message .= '<li><strong>PayPal TXN ID:</strong> ' . $txn_id . '</li></ul>';
$this->email->from( $from, $name );
$this->email->to( $this->config->item( 'admin_email' ) );
$this->email->subject( 'A purchase has been made' );
$this->email->message( $message );
$this->email->send();
$this->email->clear();

IMPORTANT! The IPN listener won’t work if you’re running on a local server (‘localhost’). Clearly if PayPal attempted to visit http://localhost/paypal/ipn/ they’re not going to arrive at your system. Upload your files to a remote server accessible by a domain name, or external IP address, for this to work.

File Downloads

The final step to getting the site fully working is to get the download links to work. When a customer goes to the download link we email them (eg. http://example.com/download/{key}), we use their key to look up the download. If the purchase associated with the key is set to active (payment fulfilled) and the file exists on the server, the download will start.

First thing we need to do is add another route to set /download/ requests to go to items/download. Add the following to your config/routes.php file:

$route['download/:any'] = 'items/download';

Now, inside your items controller, add the following download() method:

function download() { // ROUTE: download/{purchase_key}
  $key = $this->uri->segment( 2 );
  $purchase = $this->Item->get_purchase_by_key( $key );

  // Check purchase was fulfilled
  if ( ! $purchase ) {
    $this->session->set_flashdata( 'error', 'Download key not valid.' );
    redirect( 'items' );
  }
  if ( $purchase->active == 0 ) {
    $this->session->set_flashdata( 'error', 'Download not active.' );
    redirect( 'items' );
  }

  // Get item and initiate download if exists
  $item = $this->Item->get( $purchase->item_id );

  $file_name = $item->file_name;
  $file_data = read_file( 'files/' . $file_name );

  if ( ! $file_data ) { // file not found on server
    $this->session->set_flashdata( 'error', 'The requested file was not found. Please contact us to resolve this.' );
    redirect( 'items' );
  }

  force_download( $file_name, $file_data );
}

In the first couple lines we lookup the purchase using the key in the URL. On line 6, if we can’t find a purchase record with that key, we set an error message that the key is invalid and redirect the user to the homepage. Similarly, on line 10, if the purchase was not fulfilled (active is ’0′), we display an error.

We then retrieve the actual item from the database, and retrieve the file name. We use the read_file() method from CodeIgniter’s File helper to get the contents of the file. If the file can’t be found (or is empty), we display an error. Otherwise, we use the force_download() method to initiate a download.

Item Theft

We do have one problem—it’s possible to guess the name of a file and download it directly (ie. by visiting http://example.com/files/UNIX and CHMOD.txt). To fix this, simply create a file named .htaccess inside the files/ directory with the following line inside:

deny from all

This tells the server to deny any requests for files in this directory – but the server itself can still access the files so buyers can still download using their own unique link.

Stylish

At the root of your app (same location as the files and system directories), create a new directory named css, inside it create a file named style.css and add the following inside to spice things up a little:

 

body {
  background-color: #f9f9f9;
  color: #222;
  font-family: sans-serif;
}

#wrap {
  background-color: #fff;
  border: 1px solid #ddd;
  border-radius: 5px;
  -moz-border-radius: 5px;
  -webkit-border-radius: 5px;
  box-shadow: #e6e6e6 0 0 15px;
  -moz-box-shadow: #e6e6e6 0 0 15px;
  -webkit-box-shadow: #e6e6e6 0 0 15px;
  margin: 15px auto;
  padding: 15px;
  width: 760px;
}

a {
  color: #24badb;
  text-decoration: none;
}

header h1 {
  text-align: center;
}

header a {
  color: #222;
  padding: 7px 10px;
}

header a:hover {
  background-color: #222;
  color: #fff;
}

li {
  margin-bottom: 10px;
}

section {
  line-height: 1.5em;
}

section a {
  padding: 3px 4px;
}

section a:hover {
  background-color: #24badb;
  color: #fff;
}

footer {
  color: #bbb;
  text-align: right;
}

footer a {
  color: #bbb;
}

footer a:hover {
  color: #a0a0a0;
}

 

BONUS: Download Limits

You may want to limit how often a user may download their purchase within a certain time period (perhaps to stop them sharing the download link around). Implementing this feature doesn’t take much work, so let’s add it in now.

We already set up a database table to log file downloads–’downloads’–which we haven’t used yet. We also have the ‘Download Limit’ setting in the config/config.php file, so go ahead and ‘enable’ it now:

/*
|--------------------------------------------------------------------------
| Download Limit
|--------------------------------------------------------------------------
|
| How many times can an item be downloaded within a certain time frame?
|   eg. 4 downloads within 7 days
|
*/
$config['download_limit'] = array(
	'enable'	=> true,
	'downloads'	=> '4',
	'days'		=> '7'
);

The default setting is to allow up to four file downloads in a seven day period. If, for example, the buyer tries to download five times in seven days, we’ll forward them back to the home page and display an error explaining why we can’t serve up their download right now.

The first thing we need to do is keep a log every time a download is initiated. To do this, add the following directly before the force_download(...) statement at the end of the download() function in the Items controller:

$this->Item->log_download( $item->id, $purchase->id, $this->input->ip_address(), $this->input->user_agent() );

Here we’re sending the item id, purchase id and the user’s IP address and user agent to a log_download() method in the Items model which we’ll create next.

Add the following method to your Items_model:

function log_download( $item_id, $purchase_id, $ip_address, $user_agent ) {
  $data = array(
    'item_id'      => $item_id,
    'purchase_id'  => $purchase_id,
    'download_at'  => time(),
    'ip_address'   => $ip_address,
    'user_agent'   => $user_agent
  );
  $this->db->insert( 'downloads', $data );
}

This simply adds the data we provided, and the current time, to the ‘downloads’ table.

We’ll also need a method to get the downloads of a purchase, so add the following to the model:

function get_purchase_downloads( $purchase_id, $limit ) {
  return $this->db->where( 'purchase_id', $purchase_id )->limit( $limit )->order_by( 'id', 'desc' )->
get( 'downloads' )->result();
}

Now, to actually add in the download limit, find the following piece of code in the download() method in the Items controller:

// Check purchase was fulfilled
if ( ! $purchase ) {
  $this->session->set_flashdata( 'error', 'Download key not valid.' );
  redirect( 'items' );
}
if ( $purchase->active == 0 ) {
  $this->session->set_flashdata( 'error', 'Download not active.' );
  redirect( 'items' );
}

Directly after this, add the following:

 

// Check download limit
$download_limit = $this->config->item( 'download_limit' );
if ( $download_limit['enable'] ) {
  $downloads = $this->Item->get_purchase_downloads( $purchase->id, $download_limit['downloads'] );
  $count = 0;
  $time_limit = time() - (86400 * $download_limit['days']);
  foreach ( $downloads as $download ) {
    if ( $download->download_at >= $time_limit )
      $count++; // download within past x days
    else
      break; // later than x days, so can stop foreach
  }

  // If over download limit, error
  if ( $count >= $download_limit['downloads'] ) { // can only download x times within y days
    $this->session->set_flashdata( 'error', 'You can only download a file ' . $download_limit['downloads'] . 
' times in a ' . $download_limit['days'] . ' day period. Please try again later.' );
    redirect( 'items' );
  }
}

 

On the third line we check whether the ‘Download Limit’ functionality is enabled in the config file. If it is, we retrieve the downloads of the current purchase (limited to how many file downloads is permitted).

At line 6, we calculate the furthest time away downloads are limited to (eg. if we have a limit of 4 downloads in 7 days, we find the time 7 days ago) by multiplying the number of days by 86400 (the number of seconds in a day) and subtracting it from the current time.

The loop starting at line 7 checks each download logged to see if it was downloaded within the time limit (eg. 7 days). If it is, we increase $count, otherwise, we break out of the loop as we know if this logged download is older than the limit, all subsequent logs will be to.

At line 15, if the $count is greater than the number of downloads allowed, we display an error message. Otherwise, the rest of the code will be executed and the download will be logged and initiated.

We’re done. Try it out!

Note: To disable the PayPal ‘sandbox’ mode so you can recieve real payments, change the $config['paypal_lib_sandbox_mode'] option in config/paypallib_config.php to false.

Start by opening the terminal and executing the following commands:


sudo apt-get install apache2 php5 php5-mysql mysql-server



Now, test the apache by browsing to this page: http://localhost

You should get the following page:

RedBonzai Developers: Web Developers in Houston Texas Using the Lamp Stack

At this point it is a good idea to create a phpInfo.php page. So do this:


cd /var/www/

sudo gedit phpinfo.php


This will open the file that you are creating ( phpinfo). so type the following:

<?php 

phpinfo();
?&gt

now save it and go to the following url: http://localhost/phpinfo.php. You should get the INFO page with all that PHP has compiled.

Now, install phpMyAdmin:

sudo apt-get install phpmyadmin

After finishing, you need to execute this command below. This changes the phpMyadmin folder to var/www.

sudo ln -s /usr/share/phpmyadmin/ /var/www/phpmyadmin

Testing phpMyadmin http://localhost/phpmyadmin/index.php

Username for phpMyAdmin is “root”.

The first query simply updates a single column within a mysql row:

UPDATE tableName SET fieldName= 'fieldValue' WHERE fieldName2= 'fieldValue2';

The last mysql statement is fantastic for a single query. However, now suppose that we need to update multiple rows, and the field name changes in value. Said in other words, there are different fields that require a different updated value. Well, here is an example :

First, put the fields to be updated into an associative array and put it through a PHP foreach loop

<?php 
foreach ($associative_array as $field => $value) {
    $sql = "UPDATE categories SET fieldname = $value WHERE field = $field";
    mysql_query($sql);
}
?>

that should work right? … … NOPE … well, why?

OK … It will probably work, but one thing that you have to keep in mind is that you are pinging the database N times for N=the amount of rows that need to be updated. What if N=1000?

This is saying that you have N queries to make, and what if there are are N users doing the same thing? You are setting yourself up for a crash.

Is there another way? … YEP

 UPDATE mytable
    SET fieldName= CASE other_field
        WHEN 1 THEN 'value'
        WHEN 2 THEN 'value'
        WHEN 3 THEN 'value'
        WHEN 4 THEN 'value'
    END
WHERE id IN (1,2,3, 4);

OK … we are going to apply this to a PHP script, but first let’s talk about the scenario in which multiple columns must be updated within a single MySql query:

So, if the CASEis the fieldname that we are checking for, and the value of the fieldname matches the value we are checking for, then we update it to the new field value.

The WHERE clause ensures that the logic is only applied to the smallest number of rows possible. Now you can see the event in which Nis a row, and N->1000. Now see that all N rows were updated in only 1 Query. Pretty cool

What about when you need to update multiple fields instead of one? We add another CASE block.

UPDATE tableName
    SET fieldname1= CASE fieldValue1
        WHEN robot THEN 'voltron'
        WHEN truck THEN 'optimus Prime'
        WHEN websites THEN 'redbonzai'
        WHEN code THEN 'PHP'
    END,
    fieldname2= CASE fieldValue2
        WHEN 'clown' THEN 'Bozo'
        WHEN 'robot' THEN 'transformer'
        WHEN 'furry' THEN 'Teddy Bear'
        WHEN 'OS' THEN 'Linux'
    END
WHERE fieldValue2 IN ('clown', 'robot', 'furry', 'OS');

Alright, now back to the PHP example. Lets turn this into a dynamic query:

<?php
 $column1 = array(    'rice' => 'wild',
     'developer' => 'php',
     'furry'=> 'teddy bear',
     'funny'=> 'comedian',
     'work'=> 'never stops',
     'money'=> 'millionaire',
     'pink'=> 'polka dots',
     'Furniture'=> 'Modern'
  );


$column2 = array(
    'rice' => 'wild',
    'developer' => 'php',
    'furry'=> 'teddy bear',
    'funny'=> 'comedian',
    'work'=> 'never stops',
    'money'=> 'millionaire',
    'pink'=> 'polka dots',
    'Furniture'=> 'Modern'
);

$fields1 = implode(',', array_keys($column1));
$fields2 = implode(',', array_keys($column2));

$sql = "UPDATE column1 SET fieldName1= CASE fieldValue ";

foreach ($column1 as $field => $value) {
     if(is_numeric($field)){$field='$field';}else {$field=$field;}
    $sql .= sprintf("WHEN %s THEN %s ", $field, $value);
    //echo $field .": ".$value."
";
    if($field==end(array_keys($column1))){

       $sql .= "END WHERE fieldName1 IN ($fields1);";
        $sql .= "UPDATE column2 SET fieldName2 = CASE fieldValue2";
    }    
}
foreach($column2 as $field=>$value){
          if(is_numeric($field)){$field='$field';}else {$field=$field;}
            $sql .= sprintf("WHEN %s THEN %s ", $field, $value);
            if($field== end(array_keys($column2))){
                break 1;
            }

        }
$sql .= "END WHERE fieldName2 IN ($fields2)";
echo $sql; //I echoed this out so that you can copy and paste it into your IDE, and see how it works.  
Next step is: 

$query = mysql_query($sql) or die(mysql_error()); 
// there are much better ways to validate your query, but this article is not about PHP query validation, 
it is about a single query to update multiple rows. 

?>

Now in this particular example, only 8 rows are being updated, but 7 queries have been trimed, which is not insignificant. Apply this technique to a situation where hundreds or thousands of rows have to be updated and you can imagine the benefits it will have. There is a down side to this …

I understand if you have multiple rows to update, but you are ONLY updating 2 or three columns.
The more columns you update, you have to make another foreach loop.

But in the end, you end up with a pretty nice SQL string, and only 1 Query.

If you were to have a subdomain that you yourself controlled / owned and you also wanted to load content from that domain via AJAX into a page how can this be done?…. We were pondering this the other day … As you know, ( or you should know) Javascript doesn’t allow cross domain XMLHttpRequest’s or AJAX requests (Asynchronous JavaScript and XML). There is a ‘dirty’ way to get around this using PHP and CURL to pull the HTML of the page you want to get the content from so JavaScript thinks it’s coming from your domain. Let me just say, this isn’t an ideal solution but it’s a useful technique when executed in the right situation.

NOTE: You need to have PHP5 installed on your server in order to use the CURL module.

The PHP

In this example we’re taking the community news section from smashingmagazine.com. Firstly using PHP we use CURL to get the whole contents of the homepage. we can then specify using javascript a specific div to get as explained below.

 
<?php
$ch = curl_init(&quot;http://www.redbonzai.com/redbonzai/about_redbonzai.php;);
$html = curl_exec($ch);
echo $html;
?>

The JavaScript

This must be the simplest couple of lines of javascript ever. You can see within the DOM ready function we’re loading the content of the div #noupesoc into #content. As simple as that. You can specify any div or element on the page and grab it using this method.

 
 < script type="text/javascript" >
    $('document').ready(function() {
        $('#content').load('curl.php #main');
    });
&lt/script >

The HTML

 

 <body>
<?php //include '../includes/header.php';
        $link = ' <a href="http://www.redbonzai.com/blog/?p=241">Back To Tutorial</a>';
        $download = "<a href='redbonzai.com/demos/page-scrape/page-scrape.zip'<Download The Zip</a>";
        
?>
<h5><?php echo $link." ".$download;?></h5>
<div id="content"><img src="ajax-loader.gif" alt="Loading..." /></div>

<?php //include '../includes/footer.php';?>

</body>

1. Trim leading and trailing whitespace from an email address
2. Force all characters to lower-case
3. md5 hash the final string

As an example, let’s say we start with “MyEmailAddress@example.com ” (note the trailing space which our hypothetical user entered by mistake). If we md5 encode that string directly, we get the following (in PHP):

echo md5( "MyEmailAddress@example.com " );
// "f9879d71855b5ff21e4963273a886bfc"

$email = trim( "MyEmailAddress@example.com " ); // "MyEmailAddress@example.com"
 
$email = strtolower( $email ); // "myemailaddress@example.com"
echo md5( $email );
// "0bc83cb571cd1c50ba6f3e8a78ef1346"

This can easily be combined into a single line:

 
echo md5( strtolower( trim( "MyEmailAddress@example.com " ) ) ); 
You can even write a trusty function and call it: get_gravatar();

it all starts by using the principles above in PHP and do the following: 

function get_gravatar($email, $default, $size="80")
{
   return '<img src="http://www.gravatar.com/avatar.php?gravatar_id='.md5(strtolower(trim($email))).'

            &default='.$default.'&size='.$size.'&rating=PG" width="'.$size.'px" height="'.$size.'px" />'; 
}

Next request a Gravatar Profile Using PHP

I am going to show you how to get Gravatar profile data as a serialized PHP string.

Using the steps above, I am going to create the Base Request:

1. Create a valid email hash :

   echo md5( strtolower( trim( "MyEmailAddress@example.com " ) ) ); 

2. BUild the URL to request the Profile Page
3. Append .PHP to that URL to indicate that the results should be serialized in PHP format.

The result should be http://www.gravatar.com/205e460b479e2e5b48aec07710c08d50.php

So, requesting this profile in the document should look like:

In The Browser

The result is a serialized string that must be formated. I use PortableContact.net . Feel free to check it out.

An Example of the Gravatar Profile Request

This example (written in PHP, and assuming you can file_get_contents()) just loads up my profile in serialized PHP, then unserializes it and outputs my name:

 

	<?php
 
	$str = file_get_contents( 'http://www.gravatar.com/205e460b479e2e5b48aec07710c08d50.php' );
	$profile = unserialize( $str );
	if ( is_array( $profile ) && isset( $profile['entry'] ) )
		echo $profile['entry'][0]['displayName'];
 
	?>