Mostly MYSQL DBA done the partitioning but if we talk about programmer then they are unable to do.

so don’t worry friends here is the solutions for mysql partitioning in easy steps.

First run this query to you panel and check patition is on or not.

mysql> SHOW VARIABLES LIKE ‘%partition%’;

+——————-+——-+
| Variable_name | Value |
+——————-+——-+
| have_partitioning | YES |
+——————-+——-+

Result will come like this then this database fine to add table partition.

there is another query also that show all mysql plugins.

mysql> SHOW PLUGINS;

+————+———-+—————-+———+———+
| Name | Status | Type | Library | License |
+————+———-+—————-+———+———+
| binlog | ACTIVE | STORAGE ENGINE | NULL | GPL |
| partition | ACTIVE | STORAGE ENGINE | NULL | GPL |
| ARCHIVE | ACTIVE | STORAGE ENGINE | NULL | GPL |
| BLACKHOLE | ACTIVE | STORAGE ENGINE | NULL | GPL |
| CSV | ACTIVE | STORAGE ENGINE | NULL | GPL |
| FEDERATED | DISABLED | STORAGE ENGINE | NULL | GPL |
| MEMORY | ACTIVE | STORAGE ENGINE | NULL | GPL |
| InnoDB | ACTIVE | STORAGE ENGINE | NULL | GPL |
| MRG_MYISAM | ACTIVE | STORAGE ENGINE | NULL | GPL |
| MyISAM | ACTIVE | STORAGE ENGINE | NULL | GPL |
| ndbcluster | DISABLED | STORAGE ENGINE | NULL | GPL |
+————+———-+—————-+———+———+

Then create a table and insert the value in that table.

mysql> CREATE TABLE bagesh_singh (id INT, name VARCHAR(50), purchased DATE)
-> PARTITION BY RANGE( YEAR(purchased) ) (
-> PARTITION p0 VALUES LESS THAN (1990),
-> PARTITION p1 VALUES LESS THAN (1995),
-> PARTITION p2 VALUES LESS THAN (2000),
-> PARTITION p3 VALUES LESS THAN (2005)
-> );

table is created based on Year partition

Then insert some value to there

mysql> INSERT INTO bagesh_singh VALUES
-> (1, ‘desk organiser’, ’2003-10-15′),
-> (2, ‘CD player’, ’1993-11-05′),
-> (3, ‘TV set’, ’1996-03-10′),
-> (4, ‘bookcase’, ’1982-01-10′),
-> (5, ‘exercise bike’, ’2004-05-09′),
-> (6, ‘sofa’, ’1987-06-05′),
-> (7, ‘popcorn maker’, ’2001-11-22′),
-> (8, ‘aquarium’, ’1992-08-04′),
-> (9, ‘study desk’, ’1984-09-16′),
-> (10, ‘lava lamp’, ’1998-12-25′);

10 rows will be inserted in table bagesh_singh

then run
mysql> SELECT * FROM bagesh_singh
-> WHERE purchased BETWEEN ’1995-01-01′ AND ’1999-12-31′;
+——+———–+————+
| id | name | purchased |
+——+———–+————+
| 3 | TV set | 1996-03-10 |
| 10 | lava lamp | 1998-12-25 |
+——+———–+————+

thes data will come in 0.00 sec it will make your table fast because of mysql table partition

mysql> ALTER TABLE tr DROP PARTITION p2;
Query OK, 0 rows affected (0.03 sec)

you can drop partition using mysql ALTER command.

even you can add mysql table partition using ALTER command.

mysql> ALTER TABLE bagesh_singh ADD PARTITION (PARTITION p3 VALUES LESS THAN (2000));

To double check you can use this mysql command also

mysql> SHOW CREATE TABLE tr\G
*************************** 1. row ***************************
Table: bagesh_singh
Create Table: CREATE TABLE `bagesh_singh` (
`id` int(11) default NULL,
`name` varchar(50) default NULL,
`purchased` date default NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1
PARTITION BY RANGE ( YEAR(purchased) ) (
PARTITION p0 VALUES LESS THAN (1990) ENGINE = MyISAM,
PARTITION p1 VALUES LESS THAN (1995) ENGINE = MyISAM,
PARTITION p3 VALUES LESS THAN (2005) ENGINE = MyISAM
)
1 row in set (0.01 sec)

This is very gud example for range mysql partitioning

CREATE TABLE oyerecharge_com (
id INT NOT NULL,
fname VARCHAR(50) NOT NULL,
lname VARCHAR(50) NOT NULL,
hired DATE NOT NULL
)
PARTITION BY RANGE( YEAR(hired) ) (
PARTITION p1 VALUES LESS THAN (1991),
PARTITION p2 VALUES LESS THAN (1996),
PARTITION p3 VALUES LESS THAN (2001),
PARTITION p4 VALUES LESS THAN (2005)
);

ALTER TABLE oyerecharge_com ADD PARTITION (
PARTITION p5 VALUES LESS THAN (2010),
PARTITION p6 VALUES LESS THAN MAXVALUE
);

I hope this article will be usefull for you.
Best of luck

www.bageshsingh.com
www.bageshsingh.com/bagesh-blog/

I think this is next product of

http://www.ignouinfo.com/

http://www.ignoufreeprojects.com 

http://www.ignoufreeprojects.com/ignoustudentshelpline/

http://www.ignou4u.com

all website provides you ignou details, ignou assignment, ignou project for mca  bca mba etc

When Tester Think about programmer they Smile.

Do you know why because due to tester programmer always feel embarrassed because tester find some mistakes in his program.

How the tester do in software.

There is lots of testing types through which tester test the software or websites.

Hi fiend I am not the tester so I don’t have more idea about testing but yes because of my experience in web development and software development I face tester and his ideas and many more thing…. so I can explain about testing.

Some of the types is available in testing it may different from others.

Black box testing

White box testing

Unit testing

Incremental integration testing

Integration testing

Functional testing

System testing

End-to-end testing

Sanity testing

Regression testing

Acceptance testing

Load testing

Stress testing

Performance testing

Usability testing

Install/uninstall testing

Recovery testing

Security testing

Compatibility testing

Comparison testing

Alpha testing

Beta testing

SOME OTHER PEOPLE OR TESTER TOLD ME THESE TYPE OF TESTING

ACCEPTANCE TESTING

BLACK BOX TESTING

COMPATIBILITY TESTING

CONFORMANCE TESTING

FUNCTIONAL TESTING

INTEGRATION TESTING

LOAD TESTING

PERFORMANCE TESTING

REGRESSION TESTING

SMOKE TESTING

STRESS TESTING

SYSTEM TESTING

UNIT TESTING

WHITE BOX TESTING

I am a programmer so I know problem creation of tester not type of testing I feel ……. when tester find out some bug in my application but water goes out of my head when he suggest according to

his opinion. But I want to make aware to all my friends programmer don’t believe on tester when he/she suggest don’t hesitate to told him to send a mail and cc to manager which you are suggesting. This will be good way to work with tester otherwise if you change your application according to his eye the what will be next you can’t imagine some time boss asked about these changes then they are just say it was my opinion and programmer changed so what I do. This will be language of tester when his/her neck in boss cabin.

Some tester without knowing the application start testing. What happens that time tester get more bug or No more bug so every programmer should train him on his/her application which he developed. Otherwise unnecessary you will be let to deliver you application. and this will make bad impression in office.

Some programmer leave bug and try to hide them but this is not the professional way to be a

programmer if you know the bug then it should solved before tester test because you know tester will send you again to solve and the bug list mail will goes to your project manager so don’t ignore any small bug. not even bug try to make some good website or application.

Don’t fight with tester try to be friend but not general friend professional friend it means

tester always think positive about you that “you made means no bug” that sentence you should expect from tester.

Do Bug Free Program and be friend of tester this is the main mantra about programming.

When Tester Think about programmer they Smile.

Do you know why because due to tester programmer always feel embarrassed because tester find some mistakes in his program.

How the tester do in software.

There is lots of testing types through which tester test the software or websites.

Hi fiend I am not the tester so I don’t have more idea about testing but yes because of my experience in web development and software development I face tester and his ideas and many more thing…. so I can explain about testing.

Some of the types is available in testing it may different from others this is like history.

Black box testing – Internal system design is not considered in this type of testing. Tests are based on requirements and functionality.

White box testing – This testing is based on knowledge of the internal logic of an application’s code. Also known as Glass box Testing. Internal software and code working should be known for this type of testing. Tests are based on coverage of code statements, branches, paths, conditions.

Unit testing – Testing of individual software components or modules. Typically done by the programmer and not by testers, as it requires detailed knowledge of the internal program design and code. may require developing test driver modules or test harnesses.

Incremental integration testing – Bottom up approach for testing i.e continuous testing of an application as new functionality is added; Application functionality and modules should be independent enough to test separately. done by programmers or by testers.

Integration testing – Testing of integrated modules to verify combined functionality after integration. Modules are typically code modules, individual applications, client and server applications on a network, etc. This type of testing is especially relevant to client/server and distributed systems.

Functional testing – This type of testing ignores the internal parts and focus on the output is as per requirement or not. Black-box type testing geared to functional requirements of an application.

System testing – Entire system is tested as per the requirements. Black-box type testing that is based on overall requirements specifications, covers all combined parts of a system.

End-to-end testing – Similar to system testing, involves testing of a complete application environment in a situation that mimics real-world use, such as interacting with a database, using network communications, or interacting with other hardware, applications, or systems if appropriate.

Sanity testing – Testing to determine if a new software version is performing well enough to accept it for a major testing effort. If application is crashing for initial use then system is not stable enough for further testing and build or application is assigned to fix.

Regression testing – Testing the application as a whole for the modification in any module or functionality. Difficult to cover all the system in regression testing so typically automation tools are used for these testing types.

Acceptance testing -Normally this type of testing is done to verify if system meets the customer specified requirements. User or customer do this testing to determine whether to accept application.

Load testing – Its a performance testing to check system behavior under load. Testing an application under heavy loads, such as testing of a web site under a range of loads to determine at what point the system’s response time degrades or fails.

Stress testing – System is stressed beyond its specifications to check how and when it fails. Performed under heavy load like putting large number beyond storage capacity, complex database queries, continuous input to system or database load.

Performance testing – Term often used interchangeably with ‘stress’ and ‘load’ testing. To check whether system meets performance requirements. Used different performance and load tools to do this.

Usability testing – User-friendliness check. Application flow is tested, Can new user understand the application easily, Proper help documented whenever user stuck at any point. Basically system navigation is checked in this testing.

Install/uninstall testing – Tested for full, partial, or upgrade install/uninstall processes on different operating systems under different hardware, software environment.

Recovery testing – Testing how well a system recovers from crashes, hardware failures, or other catastrophic problems.

Security testing – Can system be penetrated by any hacking way. Testing how well the system protects against unauthorized internal or external access. Checked if system, database is safe from external attacks.

Compatibility testing – Testing how well software performs in a particular hardware/software/operating system/network environment and different combination s of above.

Comparison testing – Comparison of product strengths and weaknesses with previous versions or other similar products.

Alpha testing – In house virtual user environment can be created for this type of testing. Testing is done at the end of development. Still minor design changes may be made as a result of such testing.

Beta testing – Testing typically done by end-users or others. Final testing before releasing application for commercial purpose.

SOME OTHER PEOPLE OR TESTER TOLD ME THESE TYPE OF TESTING

ACCEPTANCE TESTING

Testing to verify a product meets customer specified requirements. A customer usually does this type of testing on a product that is developed externally.

BLACK BOX TESTING

Testing without knowledge of the internal workings of the item being tested. Tests are usually functional.

COMPATIBILITY TESTING

Testing to ensure compatibility of an application or Web site with different browsers, OSs, and hardware platforms. Compatibility testing can be performed manually or can be driven by an automated functional or regression test suite.

CONFORMANCE TESTING

Verifying implementation conformance to industry standards. Producing tests for the behavior of an implementation to be sure it provides the portability, interoperability, and/or compatibility a standard defines.

FUNCTIONAL TESTING

Validating an application or Web site conforms to its specifications and correctly performs all its required functions. This entails a series of tests which perform a feature by feature validation of behavior, using a wide range of normal and erroneous input data. This can involve testing of the product’s user interface, APIs, database management, security, installation, networking, etcF testing can be performed on an automated or manual basis using black box or white box methodologies.

INTEGRATION TESTING

Testing in which modules are combined and tested as a group. Modules are typically code modules, individual applications, client and server applications on a network, etc. Integration Testing follows unit testing and precedes system testing.

LOAD TESTING

Load testing is a generic term covering Performance Testing and Stress Testing.

PERFORMANCE TESTING

Performance testing can be applied to understand your application or web site’s scalability, or to benchmark the performance in an environment of third party products such as servers and middleware for potential purchase. This sort of testing is particularly useful to identify performance bottlenecks in high use applications. Performance testing generally involves an automated test suite as this allows easy simulation of a variety of normal, peak, and exceptional load conditions.

REGRESSION TESTING

Similar in scope to a functional test, a regression test allows a consistent, repeatable validation of each new release of a product or Web site. Such testing ensures reported product defects have been corrected for each new release and that no new quality problems were introduced in the maintenance process. Though regression testing can be performed manually an automated test suite is often used to reduce the time and resources needed to perform the required testing.

SMOKE TESTING

A quick-and-dirty test that the major functions of a piece of software work without bothering with finer details. Originated in the hardware testing practice of turning on a new piece of hardware for the first time and considering it a success if it does not catch on fire.

STRESS TESTING

Testing conducted to evaluate a system or component at or beyond the limits of its specified requirements to determine the load under which it fails and how. A graceful degradation under load leading to non-catastrophic failure is the desired result. Often Stress Testing is performed using the same process as Performance Testing but employing a very high level of simulated load.

SYSTEM TESTING

Testing conducted on a complete, integrated system to evaluate the system’s compliance with its specified requirements. System testing falls within the scope of black box testing, and as such, should require no knowledge of the inner design of the code or logic.

UNIT TESTING

Functional and reliability testing in an Engineering environment. Producing tests for the behavior of components of a product to ensure their correct behavior prior to system integration.

WHITE BOX TESTING

Testing based on an analysis of internal workings and structure of a piece of software. Includes techniques such as Branch Testing and Path Testing. Also known as Structural Testing and Glass Box Testing.

I am a programmer so I know problem creation of tester not type of testing I feel ……. when tester find out some bug in my application but water goes out of my head when he suggest according to

his opinion. But I want to make aware to all my friends programmer don’t believe on tester when he/she suggest don’t hesitate to told him to send a mail and cc to manager which you are suggesting. This will be good way to work with tester otherwise if you change your application according to his eye the what will be next you can’t imagine some time boss asked about these changes then they are just say it was my opinion and programmer changed so what I do. This will be language of tester when his/her neck in boss cabin.

Some tester without knowing the application start testing. What happens that time tester get more bug or No more bug so every programmer should train him on his/her application which he developed. Otherwise unnecessary you will be let to deliver you application. and this will make bad impression in office.

Some programmer leave bug and try to hide them but this is not the professional way to be a

programmer if you know the bug then it should solved before tester test because you know tester will send you again to solve and the bug list mail will goes to your project manager so don’t ignore any small bug. not even bug try to make some good website or application.

Don’t fight with tester try to be friend but not general friend professional friend it means

tester always think positive about you that “you made means no bug” that sentence you should expect from tester.

Do Bug Free Program and be friend of tester this is the main mantra about programming.

The CakePHP welcome page gives little clues as to the power that it provides – you need to get stuck in.

CakePHP requires very little to get up and going. You will need a web server, such as Apache, PHP 4+ (preferably 5+), MySQL 4+ and an editor of your choice. At the time of writing the latest release of CakePHP is v1.3.8.

You can download the latest from http://github.com/cakephp/cakephp/downloads as a compressed release, or use Git to clone the repository: http://github.com/cakephp/cakephp. Once downloaded or cloned, place the contents of the cakephp package into your document root. Once completed, you should have a docroot /directory containing the folders /app, /cake, /plugins and /vendors and the files .htaccess, index.php and README.

Set up the database

The next step is to set up a database. We’re using MySQL, as it’s the most common of the free database engines available, so go ahead and do:le for the movie application:

CREATE DATABASE linux_format_tutorial;
CREATE TABLE `movies` (
  `id` CHAR(36) NOT NULL PRIMARY KEY,
  `title` VARCHAR(255),
  `genre` VARCHAR(45),
  `rating` VARCHAR(45),
  `format` VARCHAR(45),
  `length` VARCHAR(45),
  `created` DATETIME,
  `modified` DATETIME
);

Sure, it’s a simple table, but it’s all we need to get the basic information stored and a working application as a result.

Note we’ve used a CHAR(36) field for the ID of each record in the database. CakePHP identifies this, and when storing new records it generates and stores a UUID rather than a numeric ID. This is a handy habit to get into, as it makes it easier to merge data from various databases later. This is one of the convention-based approaches of CakePHP in its ‘Convention over Configuration’ approach to application development.

Another example of this approach can be seen in the created and modified fields in the table. You don’t need to implement any of your own code to enable created to be populated with the correct date and time for each record when it is created, nor do you need to implement any code for the modified field. CakePHP jumps into action and takes care of this for you, making your application remarkably quick and easy to build.

Because we’re using the field name title for the movie title, which matches one of the default column names for CakePHP record-name identifiers, we see more magic as CakePHP automatically uses this field to display the name for records in lists etc. Create the table before moving on to the next step.

Set up the database connection

Getting the database configured in CakePHP is easy. There’s a sample database configuration ready for you at /app/config/database.php.default. The quickest way to get going is to create a copy of this file at /app/config/database.php. Edit the file copy you have created to contain credentials that match your database connection. For this application, you just need to configure the $default connection. It should look similar to the following:

var $default = array(
	‘driver’ => ‘mysql’,
	‘persistent’ => ‘false’,
	‘host’ => ‘localhost’,
	‘port’ => ‘’,
	‘login’ => ‘username’,
	‘password’ => ‘password’,
	‘database’ => ‘linux_format_tutorial’,
	‘schema’ => ‘’,
	‘prefix’ => ‘’,
	‘encoding’ => ‘’
);

You can now load the CakePHP welcome page by browsing to the location you set up on your server. You will notice a number of green bars indicating the successful setup of CakePHP. If you have any configuration issues, these green bars will appear in yellow, and will provide a detailed error message to help you solve the problem. For the purposes of this application, you an ignore any information about the Security Salt, or Cipher Key warnings on the CakePHP welcome page, as they are not required for this application.

Let’s start coding in earnest by creating MoviesController in /app/controllers/movies_controller.php.

class MoviesController extends AppController {
	public $components = array(‘Session’);
}

We have included a Session component here to handle error messages from page to page.

One by one we’ll create actions that will be available to users browsing your movie database. Actions are publicly accessible functions on a controller. For all the operations we want to perform on a movie in our movie database, we’ll create the CRUD actions on the Movies controller. CRUD is an acronym for: Create, Read, Update and Delete. Our actions will be named: index, add, edit, view and delete.

Let’s start with the index action, which will list all the movies in the database. The controller has an instance object called Movie, which is a model. It’s automatically included by CakePHP to match the controller name. We can call find() on this model and CakePHP converts those calls into database queries, meaning we don’t have to write a single line of SQL to retrieve data. Awesome! Below we call the find() method with the type all, and make the result available for the view to display.

class MoviesController extends AppController {
	public $components = array(‘Session’);
	public function index() {
		$movies = $this->Movie->find(‘all’);
		$this->set(‘movies’, $movies);
	}
}

That’s all we need for the index action. I know it looks simple, but that’s the beauty of CakePHP – there’s no point overcomplicating things.

Create your first view

With the action complete on the controller, its time to create the view so we can see the data and interact with it. Views in CakePHP are simple PHP files with a ctp file extension. You can use regular old PHP in your view files.

The movie list

Create your first view in /app/views/movies/index.ctp. You will need to create the directory movies under the /app/views directory first. Add the following code:

<div>
	<h2>Movies</h2>
	<table cellpadding="0" cellspacing="0">
		<tr>
			<th>Title</th>
			<th>Genre</th>
			<th>Rating</th>
			<th>Format</th>
			<th>Length</th>
			<th>Actions</th>
		</tr>
	<?php foreach ($movies as $movie): ?>
	<tr>
		<td><?php echo $movie['Movie']['title']; ?> </td>
		<td><?php echo $movie['Movie']['genre']; ?> </td>
		<td><?php echo $movie['Movie']['rating']; ?> </td>
		<td><?php echo $movie['Movie']['format']; ?> </td>
		<td><?php echo $movie['Movie']['length']; ?> </td>
		<td>
			<?php echo $this->Html->link('View',
array('action' => 'view', $movie['Movie']['id'])); ?>
			<?php echo $this->Html->link('Edit',
array('action' => 'edit', $movie['Movie']['id'])); ?>
			<?php echo $this->Html->link('Delete',
array('action' => 'delete', $movie['Movie']['id']),
null, sprintf('Are you sure you want to delete %s?', $movie['Movie']['title'])); ?>
		</td>
	</tr>
	<?php endforeach; ?>
	</table>
</div>
<div>
	<h3>Actions</h3>
	<ul>
		<li><?php echo $this->Html->link('New Movie', array('action' => 'add')); ?></li>
	</ul>
</div>

This will look familiar to anyone who has used HTML and PHP previously. What differs is the use of CakePHP view helpers to output information such as links. The HTML helper allows us to pass array-based information for the View, Edit and Delete actions. These are transformed into URLs such as: http://mysite.com/movies/view/1234 (in the case of a view link).

The view iterates over the $movies variable, which was set by the MoviesController earlier, and outputs all of the entries in a table (this is tabular data, after all).

You can now browse to the /movies/index URL on your server and see the output from your new view. If you have set up the server to host only the CakePHP application we are developing, you can browse to your site address as follows: http://mysite.com/movies/index. Or, if you have set up this CakePHP application in a subdirectory, simply browse to that directory on your server: http://mysite.com/my_directory/movies/index.

For the moment there are no movies in the database. Let’s push on to create the movie addition functionality. We’re on the clock here!

Create the add action and view

Next we’ll build on our existing movies controller to include an add action. It will be used to process the addition of new movies to the database. We need to check to see if any form data has ben submitted, and if so, process that information and store it after checking for errors. That sounds like a lot to achieve, but CakePHP makes it easy, as you can see in the following listing:

class MoviesController extends AppController {
	// .. components ..
	// .. index action ..

	public function add() {
		if (!empty($this->data)) {
			$this->Movie->create($this->data);
			if ($this->Movie->save()) {
				$this->Session->setFlash('The movie has been saved');
				$this->redirect(array('action' => 'index'));
			} else {
				$this->Session->setFlash
('The movie could not be saved. Please, try again.');
			}
		}
	}
}

Adding a movie with the Add view. Yes it’s simple, but the cool this is that it took so little code to produce.

The add view takes advantage of the CakePHP form helper, which makes light work of generating forms for all types of situations. Here we simply define what model we’re creating a form for (in this case, the Movie model), and what fields we want available to the users.

Create the following in /app/views/movies/add.ctp:

<div class=”movies form”>
<?php
echo $this->Form->create(‘Movie’);
echo $this->Form->inputs(array(‘title’, ‘genre’, ‘rating’, ‘format’, ‘length’));
echo $this->Form->end(‘Add’);
?>
</div>

<div class=”actions”>
	<h3>Actions</h3>
	<ul>
		<li><?php echo $this->Html->link(‘List Movies’, array(‘action’ => ‘index’));?></li>
	</ul>
</div>

The real form creation power of this view file is achieved in the three PHP echo lines at the top. The rest is HTML layout and a link to go back to the list of movies. You’re now able to view the CakePHP ‘movie add’ form by visiting the /movies/add URL, or by clicking on the New Movie link we added to the movie index page.

Brilliant! Now you can go ahead and add a couple of movies. The example in the next screenshot is adding Spider-Man 3 in Blu-ray format. As you add each entry, you are redirected back to the index view, which will show each new movie as it is added to the database.

Enable movie deletion

Perhaps you added a movie that you no longer have, or otherwise want to remove an entry from your database. We’ve created links in the views already that point to a delete action, so we’ll implement that one. The delete action does not require a view, as we don’t require any output as part of the process. The action will process the deletion, and then immediately redirect with an appropriate message.

Add the delete action to your Movies controller:

class MoviesController extends AppController {
	// .. components ..
	// .. index action ..
	// .. add action ..
	public function delete($id = null) {
		if (!$id) {
			$this->Session->setFlash(‘Invalid id for movie’);
			$this->redirect(array(‘action’ => ‘index’));
		}
		if ($this->Movie->delete($id)) {
			$this->Session->setFlash(‘Movie deleted’);
		} else {
			$this->Session->setFlash(__(‘Movie was not deleted’,
 true));
		}
		$this->redirect(array(‘action’ => ‘index’));
	}
}

We’ve already added ‘delete’ links to the index page in the previous steps. You can now remove entries from your database using the delete links! You will notice that on our index action, the code to implement the delete link was longer than the View and Edit actions. This is because we included a JavaScript alert mechanism to make sure that the user really wanted to delete that record. This is a safety mechanism to give the user a chance to back out, as there is no view associated with the action to prevent an accidental deletion.

We’ve added a delete confirmation box

<?php echo $this->Html->link(‘Delete’, array(‘action’ =>
 ‘delete’, $movie[‘Movie’][‘id’]), null,
sprintf(‘Are you sure you want to delete %s?’, $movie[‘Movie’][‘title’])); ?>

Editing your data

Even the best of us makes mistakes, so it’s a good idea to have an edit action available to jump in and correct any issues or changes with records as necessary. This action is very similar to the add action, with the main difference being the management of the existing record ID. In fact, they are so similar that seasoned CakePHP developers will combine the add and edit actions into a single action. Here’s the code:

class MoviesController extends AppController {
	// .. components ..
	// .. index action ..
	// .. add action ..
	// .. delete action ..

	function edit($id = null) {
		if (!$id && empty($this->data)) {
			$this->Session->setFlash('Invalid movie');
			$this->redirect(array('action' => 'index'));
		}
		if (!empty($this->data)) {
			if ($this->Movie->save($this->data)) {
				$this->Session->setFlash('The movie has been saved');
				$this->redirect(array('action' => 'index'));
			} else {
				$this->Session->setFlash('The movie could not be saved. Please, try again.');
			}
		}
		if (empty($this->data)) {
			$this->data = $this->Movie->read(null, $id);
		}
	}
}

The main difference between the add and edit actions is that the edit action passes an ID to the action, and does not call the create() method on the Movie object. This is because it needs to retain any existing data for the record when saving to the database.

Creating your edit view

It should all be looking familiar by now. The edit view we’re about to create looks almost identical to the add form. Again, developers that have been exposed to CakePHP for some time will integrate the add and edit form to save repeating code. The only difference is the inclusion of an input for the id field in the form, and the label on the submit button.

Create the following in /app/views/movies/edit.ctp:

<div class=”movies form”>
<?php
echo $this->Form->create(‘Movie’);
echo $this->Form->inputs(array(‘id’, ‘title’, ‘genre’, ‘rating’, ‘format’, ‘length’));
echo $this->Form->end(‘Edit’);
?>
</div>
<div class=”actions”>
	<h3>Actions</h3>
	<ul>
		<li><?php echo $this->Html->link(‘List Movies’,
array(‘action’ => ‘index’));?></li>
	</ul>
</div>

The movie detal view.

Save your view.

Time to take it for a test drive. Load up your index action in your browser as before, and click through to the edit action of one of your movies. You will be presented with a screen that contains all the inputs and data for your record. Note that the id field is not shown. This is included as a hidden field, so the user cannot tamper with this information. Our final controller action and view will provide a detail view of each movie. It will contain all the information we didn’t show in the index view such as ‘created’ and ‘modified’ times. When browsing to the view action, an ID is passed in the URL to indicate what movie ID we want to view. Add the following view action to your Movies controller:

class MoviesController extends AppController {
	// .. components ..
	// .. index action ..
	// .. add action ..
	// .. delete action ..
	// .. edit action ..

	function view($id = null) {
		if (!$id) {
			$this->Session->setFlash(‘Invalid movie’);
			$this->redirect(array(‘action’ => ‘index’));
		}
		$this->set(‘movie’, $this->Movie->findById($id));
	}
}

Create the detail view

Our last view is a simple table displaying all the movie information. Create this view in the following location: /app/views/movies/view.ctp – here’s the the code:

<div>
<h2>Movie</h2>
	<dl>
		<dt>Title</dt>
		<dd><?php echo $movie['Movie']['title']; ?></dd>
		<dt>Genre</dt>
		<dd><?php echo $movie['Movie']['genre']; ?></dd>
		<dt>Rating</dt>
		<dd><?php echo $movie['Movie']['rating']; ?></dd>
		<dt>Format</dt>
		<dd><?php echo $movie['Movie']['format']; ?></dd>
		<dt>Length</dt>
		<dd><?php echo $movie['Movie']['length']; ?></dd>
		<dt>Created</dt>
		<dd><?php echo $movie['Movie']['created']; ?></dd>
		<dt>Modified</dt>
		<dd><?php echo $movie['Movie']['modified']; ?></dd>
	</dl>
</div>

<div>
	<h3>Actions</h3>
	<ul>
		<li><?php echo $this->Html->link
('Edit Movie', array('action' => 'edit', $movie['Movie']['id'])); ?> </li>
		<li><?php echo $this->Html->link
('Delete Movie', array('action' => 'delete', $movie['Movie']['id']),
null, sprintf('Are you sure you want to delete # %s?', $movie['Movie']['id'])); ?> </li>
		<li><?php echo $this->Html->link
('List Movies', array('action' => 'index')); ?> </li>
		<li><?php echo $this->Html->link
('New Movie', array('action' => 'add')); ?> </li>
	</ul>
</div>

The last action we linked on the index page is now operational! Click through the ‘view’ link on one of the movies in your database to see the result of the detail view we have just created. Notice that it also includes a useful list of relevant actions for the current record.

As you edit information and create new records, you’ll see the created and modified fields for those records being updated by CakePHP for you. This is part of the automatic functionality that the framework provides. Edit a couple of records to see these fields change.

Where to now?

You now have a completely functional movie database application that you can host at home, or online. All in under 20 minutes. The next big issue you face is what you are going to do with all your spare time now that CakePHP is doing all the heavy lifting. Good luck, and be sure to let us know what you do with CakePHP at www.linuxformat.com/forums – whatever you do, I hope you save lots of precious time!

We’ll be following this up with more CakePHP tutorials soon – stay tuned!

For each file, we want to associate it with a user for ownership, but we also want to be able to associate it with many other users for sharing (read access). So we need to define two separate associations from file to user. We’re going to manage the sharing access with an association called “Has and belongs to many” or HABTM for short. HABTM utilises a join table to associate the two records, and has a standard within CakePHP that we’ll follow so the framework can do all the heavy lifting for us:

CREATE DATABASE `fileshare`;
USE `fileshare`;

CREATE TABLE `uploads` (
	`id` CHAR(36) NOT NULL PRIMARY KEY,
	`user_id` CHAR(36) NOT NULL,
	`title` VARCHAR(45) NOT NULL,
	`description` TEXT,
	`filename` VARCHAR(255) NOT NULL,
	`filesize` INT(11) UNSIGNED NOT NULL DEFAULT 0,
	`filemime` VARCHAR(45) NOT NULL DEFAULT 'text/plain',
	`created` DATETIME,
	`modified` DATETIME
);

CREATE TABLE `users` (
	`id` CHAR(36) NOT NULL PRIMARY KEY,
	`username` VARCHAR(45) NOT NULL,
	`password` VARCHAR(255) NOT NULL,
	`email` VARCHAR(255) NOT NULL,
	`created` DATETIME,
	`modified` DATETIME
);

The join table we mentioned identifies users that have been allowed access to specified files. The standards specify that a join table for a HABTM association is to be the tables in their plural form, joined with an underscore and listed in alphabetical order:

CREATE TABLE `uploads_users` (
  `id` CHAR(36) NOT NULL PRIMARY KEY,
  `upload_id` CHAR(36) NOT NULL,
  `user_id` CHAR(36) NOT NULL
);

Create your tables in a new database, and we’ll push on to baking the project and getting the basics running.

Ready, set… bake!

Bake is a special console command that ships with CakePHP, and is run from the console. In order for this to work effectively the cake/console path within the CakePHP package needs to be in your PATH environment variable. You can achieve this with the following in your shell: $ export PATH=”$PATH:/path/to/cakephp/cake/console” And of course you’ll need PHP available on the command line (usually available in a php-cli package, or similar). To create the skeleton structure for your project, run the following in your shell:

$ cake bake project fileshare
$ cd fileshare

Next, configure the app to connect to the database. Change the settings as shown in the following code in your config/database.php file to the appropriate settings for your databaseL

class DATABASE_CONFIG {
	var $default = array(
		'driver' => 'mysql',
		'persistent' => false,
		'host' => 'localhost',
		'login' => 'username',
		'password' => 'password',
		'database' => 'fileshare',
		'prefix' => '',
	);
}

Setting up the “default” connection is enough. And while we’re baking and having CakePHP handle all the hard work, lets bake the controllers, models and views to get the basis of our project in place.

$ cake bake all user
$ cake bake all upload

What we have at this stage is a completely ready-to-use website that associates users with many uploads and enables us to populate the database in an easy-to-use manner. But thus far, there’s no actual file upload capability, so we need to modify what CakePHP has baked for us to provide additional functionality processing the file uploads and to prevent people from adding and modifying other users’ information. Further to that, we want to secure the whole application so that only authenticated users can modify data.

Locking things down

We already have a ‘users’ table, and the user addition is working as part of the baking process if you browse to your application and append users to the URL. For example: http://localhost/fileshare/users. So what do we need to do? Well, passwords at this stage are being stored in cleartext, and we don’t seem to be asked to log in. Open up the app_controller.php file in the root of your project. This is an empty controller from which all the other controllers in the application inherit functionality. Anything we implement here will be used in all our controllers, so this is the perfect place to enforce logins. Add the Auth and Session components. Your AppController will now look like this:

<?php
class AppController extends Controller {
  var $components = array(‘Auth’, ‘Session’);
}
?>

If you try to refresh your users list, you’ll be presented with an error indicating that the login action doesn’t exist. If you look carefully, the URL has also been changed to /users/login. Fortunately all the juicy hard stuff has been implemented in CakePHP for us, so all we need to do is provide the action (function) on the controller, and a login form for users to view. Open up controllers/users_controller.php and add the login action:

function login() {
}

That’s not a mistake, it’s an empty function, and it’s all we need for authentication to log in on the controller side.

Before we get too ahead of ourselves, we need to ensure that we can register a user in case you have not already registered one. Since we’re about to complete the user authentication section, we’d be locked out of all functionality and if we didn’t make an exception for the user registration page, we’d never be able to get into our funky new system. Create a beforeFilter method on the users controller, and add the following to tell the Auth component that we’re allowed to visit the register page even if we have not yet logged in:

function beforeFilter() {
  $this->Auth->allow(‘add’);
  return parent::beforeFilter();
}

Create the login view in a new file: views/users/login.ctp, as described here:

<div>
<?php echo $this->Form->create('User');?>
	<fieldset>
 		<legend><?php __('Login'); ?></legend>
	<?php
	echo $this->Form->input('username');
	echo $this->Form->input('password');
	?>
	</fieldset>
<?php echo $this->Form->end(__('Submit', true));?>
</div>

Refresh the page that was giving an error message, and you’ll be presented with a login form. Notice that you will be allowed to visit the /users/add page, but everything else will be redirected to the /users/login page. Feel free at this point to register yourself a user. It will be useful in testing further points in the application. Take a moment to check out your database. You’ll notice that the password is hashed for us automatically. Awesome! It’s also handy to clean up some of the automatically generated fields and inputs that we won’t be using, to ensure that users only have access to things we permit. So remove the following input from both the user add and edit views in views/users/add.ctp and views/users/edit.ctp:

echo $this->Form->input(‘Upload’);

The user index is accessible until authentication is added.

Enabling file uploads

It’s high time we got some file uploading action happening. First up, let’s make an uploads directory under the project directory to place our uploaded files, then assign ownership to the user running your web server. On some distributions this user is www-data, on others it’s apache or www. You’ll need to specify the appropriate user for your system.

$ mkdir uploads
$ chown www-data uploads

Time to dive into some code! Let’s start by adjusting the upload add page to accept files, and store them in a safe manner. The bake process has generated a fairly good form for us, but we’re going to remove a couple of the automatically generated fields and replace them with a file upload field. The columns we defined in our database are primarily for automatic population. The file upload will provide all the data we need. Remove the filename, filesize and filemime inputs from the upload add view in views/uploads/add.ctp, and add in a file input. We didn’t create a column called file in the database, so CakePHP isn’t going to do all the fancy behind-the-scenes work for that field, and we also need to tell it what type that field needs to be for the file input to be generated correctly. The other small change we’re making is to remove the user_id input that CakePHP had generated for us. Instead, we’ll add some code in our controller to automatically assign files to the user who is currently logged in. Your form inputs should now look like this:

<?php echo $this->Form->create(‘Upload’, array(‘type’ => ‘file’));?>
  <fieldset>
     <legend><?php __(‘Add Upload’); ?></legend>
  <?php
  echo $this->Form->input(‘title’);
  echo $this->Form->input(‘description’);
  echo $this->Form->input(‘file’, array(‘type’ => ‘file’));
  echo $this->Form->input(‘User’);
  ?>
  </fieldset>
<?php echo $this->Form->end(__(‘Submit’, true));?>

Enabling file uploads is simple.

Processing the uploaded file

Sure, we’ve got a file in place, but we actually need to handle the file in some manner to show up an error when the file is not correctly uploaded, and to save it in our prepared writable uploads folder when it’s been completed successfully. For this we open up controllers/uploads_controller.php in the baked project, and modify the function add() to process the file if it’s available. On the third line of this function, the code attempts to save the model data. Modify the if statement to call a function that we’ll write in a moment called uploadFile(): if ($this->uploadFile() && $this->Upload->save($this->data)) {

Sounds easy enough, doesn’t it? Now let’s create the uploadFile() function in the same controller:

function uploadFile() {
  $file = $this->data[‘Upload’][‘file’];
  if ($file[‘error’] === UPLOAD_ERR_OK) {
    $id = String::uuid();
    if (move_uploaded_file($file[‘tmp_name’], APP.’uploads’.DS.$id)) {
      $this->data[‘Upload’][‘id’] = $id;
      $this->data[‘Upload’][‘user_id’] = $this->Auth->user(‘id’);
      $this->data[‘Upload’][‘filename’] = $file[‘name’];
      $this->data[‘Upload’][‘filesize’] = $file[‘size’];
      $this->data[‘Upload’][‘filemime’] = $file[‘type’];
      return true;
    }
  }
  return false;
}

Again, we’re keeping things simple. We upload the file, and if we’re able to move it successfully into place, we return true. In the process of doing this, we are manually generating an ID which we use as a safe filesystem name for storage. This eliminates any issues that users may attempt to introduce with weird and potentially system-damaging filenames that would otherwise be directly stored on your filesystem. Manually generating the UUID with String::uuid() removes this security hole, and ensures a safe file upload, while maintaining the original filename in the database to send to the user when downloading.

The next thing we’re going to integrate is the ability to download files. But before going too far, try adding a couple of files. You’ll see them successfully being added to the database, and if you look at the uploads directory we created, matching ID named files start appearing within. If you experience any issues at this point, ensure that your web server user has write access to the uploads directory.

The other cool thing we’re doing here is assigning the user with $this->Auth->user(‘id’) which is the ID of the currently logged-in user. Since we locked down the security earlier, we know that users need to be logged in to reach this page, so the value will always be present and valid.

Cleaning up associations

You’ll notice that we’ve doubled up on our associations for both the User and Upload model. Take for example the User model in models/user.php; CakePHP has generated a hasMany and a hasAndBelongsToMany association both with the index Upload. This just won’t do, because the clash in naming will cause incorrect data to output in the views. Change the hasAndBelongsToMany association in the User model to be SharedUpload. And similarly for the Upload model in models/upload.php, change the HABTM association to be SharedUser:

// User Model
var $hasAndBelongsToMany = array(
  ‘SharedUpload’ => array(
    ‘className’ => ‘Upload’,
    ...

// Upload Model
var $hasAndBelongsToMany = array(
  ‘SharedUser’ => array(
    ‘className’ => ‘User’,
      ..

In order for these association key changes to correctly render in the views, you’ll need to change the index referenced on the views in the related section at the bottom of the view indexes. In views/users/view.ctp, the following two lines:

<?php if (!empty($user[‘pload’])):?>
foreach ($user[‘Upload’] as $upload):

are changed to:

<?php if (!empty($user[‘SharedUpload’])):?>
foreach ($user[‘SharedUpload’] as $upload):

At this point you can register a new user, log in to the system, upload files and assign users. We’ve achieved a massive amount of functionality for minimal code and effort. Give the system a good test before moving on the the next step.

Viewing and downloading files

If you have played around with the navigation in the views we have already, you’ll have come across the view page for one of your uploaded files. It shows all the meta information about the file, but at this point you can’t retrieve the file itself. Let’s tweak a few things to enable downloads so we can get at the files. The first thing to do is add a link to the view file views/uploads/view.ctp. You can add this wherever you like (I prefer to add it at the bottom of the existing data):

<dt<?php if ($i % 2 == 0) echo $class;?>><?php __(‘Download’); ?></dt>
<dd<?php if ($i++ % 2 == 0) echo $class;?>>
  <?php echo $this->Html->link(__(‘Download’, true), array(‘action’ => ‘download’, $upload[‘Upload’][‘id’])); ?>

</dd>

With the link created, it’s time to get our hands dirty again and put together the action for the controller to handle the file download. Open up your UploadsController in controllers/uploads_controller.php one more time and add the following download function. This forces download, and returns the file to the user with the original filename that was present when the file was uploaded. Here’s the code:

function download($id = null) {
	if (!$id) {
		$this->Session->setFlash(__('Invalid id for upload', true));
		$this->redirect(array('action' => 'index'));
	}
	$this->Upload->bindModel(array('hasOne' => array('UploadsUser')));
	$upload = $this->Upload->find('first', array(
		'conditions' => array(
			'Upload.id' => $id,
			'OR' => array(
				'UploadsUser.user_id' => $this->Auth->user('id'),
				'Upload.user_id' => $this->Auth->user('id'),
			),
		)
	));
	if (!$upload) {
		$this->Session->setFlash(__('Invalid id for upload', true));
		$this->redirect(array('action' => 'index'));
	}
	$this->view = 'media';
	$filename = $upload['Upload']['filename'];
	$this->set(array(
		'id' => $upload['Upload']['id'],
		'name' => substr($filename, 0, strrpos($filename, '.')),
		'extension' => substr(strrchr($filename, '.'), 1),
		'path' => APP.'uploads'.DS,
		'download' => true,
	));
}

You can now try out your download link, and you’ll get the file being downloaded via your browser! There’s a fair bit going on in this function, but believe me, there’s far more being taken care of by CakePHP that you don’t need to worry about. We’re first inspecting the ID to ensure it was supplied. Next, we try to lookup an upload record from the database with that ID, and while we’re in there, we ensure that the ID of the upload is associated with the currently logged-in user, or that the file was originally uploaded by the user who is logged in. In either case, we are allowed access. If that query failed, the user is attempting to access a file to which they have not specifically been granted permission, so we redirect them to the index list of files.

Showing only what users can access

In order to make the file list make sense for all users, you’ll also need to modify the index() action on the Uploads controller, to perform similar filtering to show only the files that are permitted in the users rendered list, otherwise it’ll clog up with files they don’t actually have access to see! Adjust the index action thus:

function index() {
  $this->Upload->bindModel(array(‘hasOne’ => array(‘UploadsUser’)), false);
  $this->paginate = array(
    ‘conditions’ => array(
      ‘OR’ => array(
        ‘UploadsUser.user_id’ => $this->Auth->user(‘id’),
        ‘Upload.user_id’ => $this->Auth->user(‘id’),
      ),
    )
  );
  $this->set(‘uploads’, $this->paginate());
}

We’ve had to add the false parameter on the bindModel() call this time to ensure that the pagination result came out correctly. Pagination takes two separate database results to return the data. The first of these determines the number of elements in the table that match the query, and the second actually retrieve the data. The false parameter tells CakePHP to retain the binding beyond a single query. The simple rule, of course, is that if you are using bindModel and pagination, you need to add false on the end.

The view() action also benefits from the same filtering:

function view($id = null) {
  if (!$id) {
    $this->Session->setFlash(__(‘Invalid upload’, true));
$this->redirect(array(‘action’ => ‘index’));
  }

  $this->Upload->bindModel(array(‘hasOne’ => array(‘UploadsUser’)));
  $upload = $this->Upload->find(‘first’, array(
    ‘conditions’ => array(
      ‘Upload.id’ => $id,
      ‘OR’ => array(
        ‘UploadsUser.user_id’ => $this->Auth->user(‘id’),
        ‘Upload.user_id’ => $this->Auth->user(‘id’),
      ),
    )
  ));
  if (!$upload) {
    $this->Session->setFlash(__(‘Invalid upload’, true));
    $this->redirect(array(‘action’ => ‘index’));
  }
  $this->set(‘upload’, $upload);
}

Wrapping it up

The only last nicety that would be required to take this site live is a logout function. And I’ll be kind enough to give you the code to put on the UsersController for logout:

public function logout() {
  $this->redirect($this->Auth->logout());
}

There’s no view required, and redirection happens as soon as the user hits the /users/logout URL, after destroying the session and logging out the user.

So we’ve built a secure, file-uploading, multi-user sharing web application, and it’s only taken 20 minutes or so to get it all done. From here, you can add extra functionality such as thumbnail icons to preview content that users have uploaded, or a different sharing mechanism to select users without exposing the complete user list to everyone. You can also enable email notifications for users that you are sharing files with. I hope you’ve enjoyed this tutorial, and I hope it’s useful for you either as a case study, or as a deployable solution for client file sharing.

The additional link enables us to download files that have been uploaded.

We’re jumping in the deep end, and build a bookmarking site that will not only store URLs and associated information for us, but generate some pretty sweet thumbnails and store those for use too. Because we’re a social community these days, we’ll include some nifty tools from a useful plugin to enable quick and easy social network sharing and publishing to get the word out about a URL that we’ve published.

As always, we put in some time ensuring that our database fits the CakePHP conventions and standards so that the heavy lifting later on is handled by CakePHP. Don’t stress though, if you want to deviate from the standards or structure here, it’s extremely easy to customise, depending on what you’re changing. Check out http://book.cakephp.org/view/901/CakePHP-Conventions for a list of the conventions adopted by the core, and for information on what you need to do to break free and go your own way.

Take a moment to consider the data we need to store. We’ll need: URLs, users and ratings, so that when we share the bookmarked URLs via Twitter, Facebook or whatever our preferred social network giant is, people can rate the content if they like it.

CREATE DATABASE `bookmark`;
USE `bookmark`;
CREATE TABLE `urls` (
	`id` CHAR(36) NOT NULL PRIMARY KEY,
	`user_id` CHAR(36) NOT NULL,
	`name` VARCHAR(128) NOT NULL,
	`url` TEXT,
	`created` DATETIME,
	`modified` DATETIME
);
CREATE TABLE `users` (
	`id` CHAR(36) NOT NULL PRIMARY KEY,
	`username` VARCHAR(45) NOT NULL,
	`password` VARCHAR(255) NOT NULL,
	`email` VARCHAR(255) NOT NULL,
	`created` DATETIME,
	`modified` DATETIME
);

Hang on a moment… surely that can’t be all the tables we need? That list of information we wanted to include for each bookmark was pretty long. And it doesn’t look like there are enough fields in that table to hold all the data – except that each plugin is capable of distributing database information that it needs in a segregated way to ensure that you have all the functionality you need packaged in the plugin that provides it, including the database storage requirements.

Okay, but how does it work? Its done by using either the ‘Schema’ shell, which comes with CakePHP, or by using the ‘Migrations’ plugin, which is developed by the Cake Development Corporation. We’ll run through the migrations plugin, because it provides much more functionality, while still remaining easy to use.

Time to hit the oven, baking time!

Bake is a console command for CakePHP, and it enables you to generate code, run migrations, run tests and much more. In order for this to work effectively from your console, the cake/console path within the CakePHP package needs to be in your PATH environment variable. You can achieve this with the following in your shell:

$ export PATH="$PATH:/path/to/cakephp/cake/console"

The only other requirement is that you have PHP available on your command line. Most distros have a php-cli package or similar to provide a command line interface PHP binary.

Bake a new project to create the skeleton structure we need to get moving. Run the following in your shell:

$ cake bake project bookmark
$ cd bookmark

CakePHP has created a basic app structure for you to use. This includes the directories and some basic initial files for you to use to serve static pages. Feel free to dig around and see exactly what has been produced for you. It’s a good idea to get familiar with the file structure that CakePHP adopts.

Before we bake, let’s tell CakePHP how to connect to our database. Take a copy of the /config/database.php.default file and rename it to /config/database.php. Enter in your database configuration to match the user details for your local database install. Here’s what my config shows:

<?php
class DATABASE_CONFIG {
	var $default = array(
		'driver' => 'mysql',
		'persistent' => false,
		'host' => 'localhost',
		'login' => 'dev',
		'password' => 'dev',
		'database' => 'bookmark',
		'prefix' => '',
	);
}

You’ll note that I have removed the test database configuration from the file. The test configuration is used for unit testing, and in this tutorial we won’t be touching on it.

Let’s get cracking on the baking of models, views and controllers for the database tables we created earlier. Baking will generate all the code we need to get the common functionality working, and will enable us to customise from there, saving a whole lotta time.

$ cake bake all user
$ cake bake all url

Don’t be alarmed by the amount of output text from the bake command; the more it outputs, the more time it has saved you through generating code. If you take a look at the output, you’ll see file paths and names to all the files that have been created for you. You now have a user and URL management system, and can browse through to add and edit that information. Try browsing to /users on your site. For example, I baked into my webroot, and so the URL I use is: http://localhost/bookmark/users. You’ll be greeted with the users index page, and from here you can navigate around to add and edit users.

Enabling authentication

We’ll quickly run through locking the system down so we can create users and log in, but not access anything else until we are logged in. This is a great way to secure your system, and its dead easy to do!

Open up the app_controller.php file in the root of your project. This is an empty controller from which all the other controllers in the application inherit functionality. Anything we implement here will be used in all our controllers, so this is the perfect place to enforce user authentication, and keep out nasty guests from editing data. Add the “Auth” and “Session” components. Your AppController will now look like this:

<?php
class AppController extends Controller {
	var $components = array('Auth', 'Session');
	function beforeFilter() {
		$this->set('authUser', $this->Auth->user());
		return parent::beforeFilter();
	}
}

You’ll note we snuck in a set call in the function beforeFilter there. This will ensure that we have access to the current user information in the views throughout the site. If there is no user currently logged in, this will be set to null.

Next, open up /controllers/users_controller.php and add a login action. This can be empty, as CakePHP handles the tricky stuff behind the scenes. While we’re digging around, also add the logout function for logging out users:

function login() {
}

function logout() {
	return $this->redirect($this->Auth->logout());
}

Finally, on the controller side, we want to ensure that we don’t have to log in to create a user, otherwise we’d be stuck with no users, and no way to create one! Add the following to your users controller:

function beforeFilter() {
	$this->Auth->allow('add');
	return parent::beforeFilter();
}

The final piece of this puzzle is the view file, which isn’t created with the CakePHP bake tool. This will take the username and password and enable users to log in. Create the login view in a new file: /views/users/login.ctp:

<div>
<?php echo $this->Form->create('User', array('url' => array('action' => 'login')));?>
	<fieldset>
 		<legend><?php __('Login'); ?></legend>
	<?php
	echo $this->Form->input('username');
	echo $this->Form->input('password');
	?>
	</fieldset>
<?php echo $this->Form->end(__('Login', true));?>
</div>

Browse back to your users list (http://localhost/bookmark/users) and you’ll immediately be redirected to the user login form. Now, try visiting the user addition page (http://localhost/bookmark/users/add) and you’ll note that you are allowed to view this page, and thus not redirected away to log in. Brilliant! It couldn’t get any easier!

Time for a fresh coffee and a pat on the back. Your data is secure, and your site works. Take a spin around the app and create a new user. Log in and test that it works correctly, and add a URL or two. Once you are happy with how that is operating and you are familiar with the site, we’ll move on to including plugins, and getting the cool stuff working!

Back in school they’d kick you out for it.. But here you’re welcome to grab people’s code and use it in your project to enhance functionality, or just save time. Just remember to check the licensing of the plugins you choose to use, as they may not be compatible with the project you are building.

How to cheat

Let’s go hunting for plugins, grab what we need and set up the directories in /app/plugins. For the purposes of this plugin installation, I’m going to assume that you have Git installed. Using Git will speed up the download and organisation of our application plugins for usage. And while you’re at it, its a great way to get used to using Git for version control if you’re not already familiar with it.

Run the following Git commands in your console:

git clone https://github.com/CakeDC/migrations.git plugins/migrations
git clone https://github.com/CakeDC/ratings.git plugins/ratings
git clone https://github.com/CakeDC/search.git plugins/search
git clone https://github.com/predominant/cake_social.git plugins/cake_social
git clone https://github.com/predominant/goodies.git plugins/goodies

You’ve just saved yourself months of development time. No kidding. You’re utilising a bunch of open source plugins that are available to any CakePHP developer who wants to use it, to cover the common functionality in your application. This saves time and money and lets you get on to leisure time quicker than the rest of the developers. Bonus!

Running migrations

Earlier I mentioned that we had a lack of database tables, but that would be taken care of by database migrations. That time has come, and you’ll see how simple database table creation can be for plugins and code reuse through projects. Not all plugins need or have migrations. Those that do will have a migrations directory in their config directory. For example, you will see the directory /plugins/ratings/config/migrations. You can check through to see what needs migrations, or just run them all, and you’ll get an error message for those that didn’t actually have migrations available, which is fine.

Run the following to complete the table setup for the plugins we’ve introduced:

$ cake migration -plugin ratings all

You should now have all the tables you need for the site!

Let’s start by enabling ratings. We want those accessible for URLs only. Adding the component is really easy. Open up the UrlsController in /controllers/urls_controller.php and add the Ratings component. Your resulting code will now look like the following:

class UrlsController extends AppController {
	var $components = array('Ratings.Ratings');
		// ... existing code ...
}

What’s super cool about this is that the component we’ve just added takes care of including the helper that you need to display the ratings form, as well as handles the saving and loading of ratings information for you. So all you need to do is set up your view as you like it to show the form for ratings, through the ratings helper, and the rating itself. Now being a truly portable and flexible plugin, the ratings information isn’t averaged or calculated for you on load, since that would be making the assumption that we know what maths you need applied for your specific situation. So some effort is required to get the right value showing, and to get the form showing only when users have not yet rated it.

The next section of code is pretty big;

<?php
$rated = Set::extract('/Rating[user_id=' . $authUser['User']['id'] . ']', $url);
if (empty($rated)): ?>
	<dt<?php if ($i % 2 == 0) echo $class;?>><?php __('Rate'); ?></dt>
	<dd<?php if ($i++ % 2 == 0) echo $class;?>>
	<?php echo $this->Rating->display(array(
	    'item' => $url['Url']['id'],
	    'type' => 'radio',
	    'stars' => 5,
	    'createForm' => array(
			'url' => array_merge(
				$this->passedArgs,
				array(
					'rate' => $url['Url']['id'],
					'redirect' => true))
			)
	)); ?>

	</dd>
<?php else: ?>
	<dt<?php if ($i % 2 == 0) echo $class;?>><?php __('Rating'); ?></dt>
	<dd<?php if ($i++ % 2 == 0) echo $class;?>>
		<?php
		$ratings = Set::extract('/Rating/value', $url);
		echo array_sum($ratings) / count($ratings); ?>

	</dd>
<?php endif; ?>

There are two main sections to the code: the first shows the form if you have not already rated the current bookmark, and the second displays our rating. Both sections of code use the Set class, which makes it easy to handle larger collections of data, and enables filtering. Add the code just after the dl tag at the start of your URLs view in /views/urls/view.ctp.

Browsing to a URL now shows a set of radio buttons, and a Rate Submission button. Sweet! Give it a go, rate a URL – you’ll be redirected to the same page, and the resulting rating will be displayed for you. Feel free to test this out some more by using another user, and see how the resulting rating changes to be the average of all the rates submitted. Pretty darn cool!

Using gravatars

The URL view page is pretty bland. There, I said it! What we really should do is at least include some more imagery and items to represent the information on the page in a more rapid manner for visitors. We’ll leave the complexities of CSS and styling the page to perfection to the web designers, but we will make their job easy through using gravatars to show user icons from the user information we have for each URL. A gravatar is a global avatar, and is provided for free through http://gravatar.com. We included a Goodies plugin when we cloned all the plugins, and the gravatar helper is just one of the awesome things that this plugin provides.

Enough sales talk.. Lets get some gravatars showing. If you have not done already, head over to the gravatar website, register your account for free, and set up a gravatar. Next, open up the URLs view (/views/urls/view.ctp). Scroll down to where the User information is output. The line we’re going to replace is:

<?php echo $this->Html->link($url['User']['id'], array('controller' => 'users', 'action' => 'view', $url['User']['id'])); ?>

Replace this with a similar code link, but this time, include the output of the gravatar helper:

<?php echo $this->Html->link(
	$this->Gravatar->image($url['User']['email']),
	array('controller' => 'users', 'action' => 'view', $url['User']['id']),
	array('escape' => false)); ?>
<?php echo $url['User']['username']; ?>

Finally, include the helper in your AppController in /app_controller.php:

class AppController extends Controller {
	var $helpers = array('Html', 'Form', 'Session', 'Goodies.Gravatar');
	// ... existing code ...
}

This will show the user’s gravatar based on their email address supplied at registration time, and also their username, instead of that ugly UUID string. Go ahead, refresh the page or browse to another URL to view it, and the gravatar will be shown in place of the user information.

Adding a social sharing widget

Let’s do one more step to fancy up the extra information and add some social sharing capabilities to promote more people to visit our site, and to enable users to share the bookmarks they really like. This functionality comes from the CakeSocial plugin we added at the beginning. The CakeSocial plugin includes a helper for the “ShareThis” service, which makes social sharing really simple. So a simple plugin for a simple service, should be super simple, right? Judge for yourself. Add the helper to the AppController in /app_controller.php:

class AppController extends Controller {
	var $helpers = array('Html', 'Form', 'Session', 'Goodies.Gravatar', 'CakeSocial.ShareThis');
	// ... existing code ...
}

And just before the closing tag on your view for URLSs /views/urls/view.ctp include the following:

<dt<?php if ($i % 2 == 0) echo $class;?>><?php __('Share'); ?></dt>
<dd<?php if ($i++ % 2 == 0) echo $class;?>>
	<?php echo $this->ShareThis->display(); ?>

</dd>

Whoa! There are five lines of code for that view, but only one is doing the social output. The rest is wrapping styles for the output, and a label. Reload your page and you’ll have the ShareThis social helpers appear, and you can share on a list of default services.

Icing on the cake: Web thumbnails

Since we saved so much time using plugins and getting these awesome features included, we have some spare time to include a cool feature like thumbnailing. Wouldn’t it be cool to have a small picture of the website pop up when we’re looking at the view page for a URL? That really would be the icing on the cake.

We’re going to take advantage of another helper from the Goodies plugin to grab the thumbnail from the Thumboo service (http://www.thumboo.com). Fetching on each view is not loading your server, as the request is handled by the external service, and it ensures that your thumbs are always up to date!

Head over to Thumboo (http://www.thumboo.com) and create an account for free. You’ll be given an API Access key. Hold on to that, you’ll need it later.

Once more unto the breach! Or, once more we’ll edit the AppController `/app_controller.php`, and add a helper. Add the Thumboo helper from the Goodies plugin:

class AppController extends Controller {
	var $helpers = array('Html', 'Form', 'Session', 'Goodies.Gravatar', 'CakeSocial.ShareThis', 'Goodies.Thumboo');

	// ... existing code ...
}

Almost there! Switch back to the view for urls `/views/urls/view.ctp` and add the following immediately after the heading at the top of the file:

<?php echo $this->Thumboo->image($url['Url']['url']); ?>

We’ve used the smallest form possible to call the helper, and we have not yet supplied that extremely easy to remember API key that Thumboo has provided us with. For this, we’re going to create a configuration file, and CakePHP will load this up as it needs it to read the key value. Using this method lets you keep configuration separate from code, and its a great way to kep your secure information safe.

Create a new file in `/config/thumboo.php` and add the following, replacing the key value with what you were supplied after signup:

<?php
$config = array(
	'Thumboo' => array(
		'Key' => 'MY KEY HERE',
	)
);

Reload your page and revel in the beauty of what has been achieved in such a short period of time. You’ve earned yourself a beer.

Where to now? The app you have built today is a good example of how quickly you can build apps with CakePHP, and the quality of the plugins that are available for free within the community. The current app has a lot of potential to expand to provide extra details like private URLs, a REST service for integration, a bookmarklet that uses Ajax that you can include for your browser, some styling, and removal of some default data and pages. The possibilities are endless!

very fast. Firstly choose which table being used every time for delete, insert or update make a list and always repair these tables.

after 15 days.

this is very good question for mysql interview best of luck hope this will help for your good career.

Prioritise your queries as LOW_PRIORITY, HIGH_PRIORITY, or DELAYED when it matters

Don’t use SELECT * unless you must

Use the EXPLAIN keyword to see how MySQL will execute your query – make sure your indexes are being used!

Load your data before adding indexes is faster than adding indexes first

Be wary of locks

Use –log-slow-queries to see where your tables can be optimised

Increase your buffer sizes so that MySQL can cache more

Use SHOW STATUS to make sure your MySQL server is in good condition

Don’t create indexes you aren’t going to use

Do as much as your filtering in SQL as you can

Indexes are good for reads, but bad for writes

Use OPTIMIZE TABLE and ANALYZE TABLE regularly

Create your tables with a fixed-table format if possible

Use the most efficient table type for each table

Use the best data type, including NOT NULL if appropriate – don’t rely on automatic type conversion

Use default values for INSERT when you can

Use temporary tables rather than heavy PHP work

SELECT foo IN (list, of, constants) is very fast

When joining tables, use numbers instead of strings if you can

once you optimize your php code then your applicationa and website will be very fast
this will make quality code. Hi php programmer don’t forget these rules if you want to
be good in php and want to work in MNC because all mnc and all good companies follow
these rules strictly even this is gud question for interview for php. best of luck.

What is the process for PHP code Optimisation.

Use the Zend Optimizer and a code cache

Use the comma operator to join arguments when calling echo

Priorities optimisation of tight loops for the most payback

Pre-increment where possible

Don’t rely on references without testing; they are rarely as effective as you’d think

Get a good understanding of how garbage collection works

Listen to all errors, big and small – they slow things down

Store a local pointer to an array element to save indexing into the array each time you need it

Compress your output to save network bandwidth

Try to avoid using PHP in CGI mode

Avoid calling the dl() function

Use persistent resource where appropriate

Optimise compilation of your PHP binary if possible

Avoid mod_access if you can

Don’t fret about Apache 2.0

As a last resort, try inlining function

All of friends I am going to share my Experience about the company and Programmer ,what I feel in last 7 Years and I work at 13

places (What was my position there Trainer, Programmer, Sr. Programmer and finally Team Lead) at some places I do the job on Saturday and Sunday.

What Programmer and Company Think.

Every Programmer Think his/her salary is low as per work they are doing but some freshers think when they get the job in company

after showing some fake experience Company is fool but he/she has no idea that the company know about that even some times I take

interview and I know this is fake company but the person who sited front of me is very talented and fast learner. That’s the reason we entertain.

Every Company always think We are paying more than programmer’s capability But the company show two different strategy First they will realized you to you are getting good salary here and you are the most quality programmer and once you reach your one year or 6 month there or when the times comes for increment then the company always try to demoralize you and will try to proof that you are not right person to get increment.and you will get frustrated and start thinking is really I am not good programmer.

But some exceptional company also available they give you more than you expect but when it happens. the case is when the third person is dealing then you get more salary in any company like the boss is not dealing the salary.

What Programmer should do at work place.

In the software company lots of people work so it’s a natural everybody will have different quality, culture and most is different

Thinking.

Programmers works depend on these three most important categories (quality, culture and Thinking).
If Programmer have good quality then they will do very good job and very good increment and appreciation from boss. If the

programmer quality is not good then they will start freelancing from the company and no doubt freelancing give money but programmer

always feel unsecured because they are doing some wrong with his/her profession.

I have seen most of the programmer do the freelancing at the work place but I felt that instead of doing freelancing at office programmer should concentrate on their work and project. or if you don’t have much work then you should start learning session to make your professional quality stronger.

How any programmer will feel secure in Company.

If you are good learner and like to study at home then you will feel always secure.This is main mantra to feel secure. Other than there are no any formula will work.

How to make good environment.

Once you join, then take some days for fluent interaction means take time to understand people see I have live example.

Don’t Talk personal thing to anybody.
Don’t talk bad about any people even ignore that people who always talks like that try to avoid politics.
Don’t make someone special behave same to everybody.
Always try to share your ideas to your boss and project manager Means always Open your mouth Don’t be Ideal.

In My career one of my best project manager is “SAHU SIR” I can’t disclose the company name. He is always look cool and he always appreciate your work and your honesty.

Most Important Don’t take quick DECISION in company for the people and JOB.

MOST PROFESSIONAL LINE

Great minds discuss ideas,average minds discuss events,small minds discuss about people….!! So what you want to be

Article By: Bagesh Singh
Email : bageshsingh@gmail.com
Highly COPYRIGHTED