Welcome,
In this blog we will learn Blog Application
This blog will walk you through the creation of a simple blog application. We’ll be getting and installing Cake, creating and configuring a database, and creating enough application logic to list, add, edit, and delete blog posts.
STEPS
1.Create a Post Model
2.Create a Posts controller
3.Creating Post Views
4.Adding Posts
5.Data Validation
6.Editing Posts
7.Deleting Posts
8.Setting Routes
Create a Post Model
Create a Posts Controller
Next, we’ll create a controller for our posts. The controller is where all the business logic for post interaction will happen. In a nutshell, it’s the place where you play with the models and get post-related work done. We’ll place this new controller in a file called PostsController.php inside the /app/Controller directory.
Now, lets add an action to our controller. Actions often represent a single function or interface in an application. For example, when users request www.example.com/posts/index (which is also the same as www.example.com/posts/), they might expect to see a listing of posts. The code for that action would look something like this:
<?php
class PostsController extends AppController {
public function index() {
$this->set('posts', $this->Post->find('all'));
$this->set('title_for_layout','our blog title');
}
Let me explain the action a bit. By defining function index() in our PostsController, users can now access the logic there by requesting www.example.com/posts/index. Similarly, if we were to define a function called foobar(), users would be able to access that at www.example.com/posts/foobar.
The single instruction in the action uses set() to pass data from the controller to the view (which we’ll create next). The line sets the view variable called ‘posts’ equal to the return value of the find('all') method of the Post model. Our Post model is automatically available at $this->Post because we’ve followed Cake’s naming conventions.
Creating Post Views
Now that we have our data flowing to our model, and our application logic and flow defined by our controller, let’s create a view for the index action we created above.
Cake’s view files are stored in /app/View inside a folder named after the controller they correspond to (we’ll have to create a folder named ‘Posts’ in this case). To format this post data in a nice table, our view code might look something like this:
<?php
class PostsController extends AppController {
public function index() {
$this->set('posts', $this->Post->find('all'));
$this->set('title_for_layout','our blog title');
}
public function view($id) {
$this->Post->id = $id;
$this->set('post', $this->Post->read());
}
Go to index file and update
} }
<h1>Add Post</h1>
<?php
echo $this->Form->create('Post');
echo $this->Form->input('title');
echo $this->Form->input('body', array('rows' => '3'));
echo $this->Form->end('Save Post');
?>
<td>
<?php echo $this->Html->link('Edit', array('action' => 'edit', $post['Post']['id']));?>
</td>
Deleting Posts
Start with a delete() action in the PostsController:
function delete($id = null) {
$this->Post->delete($id) ;
$this->Session->setFlash('The post with id: ' . $id . ' has been deleted.');
$this->redirect(array('action' => 'index'));
}
}
Go to index file and update
In this blog we will learn Blog Application
This blog will walk you through the creation of a simple blog application. We’ll be getting and installing Cake, creating and configuring a database, and creating enough application logic to list, add, edit, and delete blog posts.
STEPS
1.Create a Post Model
2.Create a Posts controller
3.Creating Post Views
4.Adding Posts
5.Data Validation
6.Editing Posts
7.Deleting Posts
8.Setting Routes
Create a Post Model
CakePHP’s model class files go in /app/Model, and the file we’ll be creating will be saved to /app/Model/Post.php. The completed file should look like this:
<?php
class Post extends AppModel {
}
Naming convention is very important in CakePHP. By naming our model Post, CakePHP can automatically infer that this model will be used in the PostsController, and will be tied to a database table called posts
Create a Posts Controller
Next, we’ll create a controller for our posts. The controller is where all the business logic for post interaction will happen. In a nutshell, it’s the place where you play with the models and get post-related work done. We’ll place this new controller in a file called PostsController.php inside the /app/Controller directory.
Now, lets add an action to our controller. Actions often represent a single function or interface in an application. For example, when users request www.example.com/posts/index (which is also the same as www.example.com/posts/), they might expect to see a listing of posts. The code for that action would look something like this:
<?php
class PostsController extends AppController {
public function index() {
$this->set('posts', $this->Post->find('all'));
$this->set('title_for_layout','our blog title');
}
Let me explain the action a bit. By defining function index() in our PostsController, users can now access the logic there by requesting www.example.com/posts/index. Similarly, if we were to define a function called foobar(), users would be able to access that at www.example.com/posts/foobar.
The single instruction in the action uses set() to pass data from the controller to the view (which we’ll create next). The line sets the view variable called ‘posts’ equal to the return value of the find('all') method of the Post model. Our Post model is automatically available at $this->Post because we’ve followed Cake’s naming conventions.
Creating Post Views
Now that we have our data flowing to our model, and our application logic and flow defined by our controller, let’s create a view for the index action we created above.
Cake’s view files are stored in /app/View inside a folder named after the controller they correspond to (we’ll have to create a folder named ‘Posts’ in this case). To format this post data in a nice table, our view code might look something like this:
<!-- File: /app/View/Posts/index.ctp -->
<h1>Blog posts</h1>
<p><?php echo $this->Html->link("Add Post", array('action' => 'add')); ?></p>
<table>
<tr>
<th>Id</th>
<th>Title</th>
<th>Action</th>
<th>Created       Modified</th>
</tr>
<!-- Here's where we loop through our $posts array, printing out post info -->
<?php foreach ($posts as $post): ?>
<tr>
<td><?php echo $post['Post']['id']; ?></td>
</tr>
<?php endforeach; ?>
</table>
Now let’s create the view for our new ‘view’ action and place it in /app/View/Posts/view.ctp.
<!-- File: /app/View/Posts/view.ctp -->
<h1><?php echo h($post['Post']['title'])?></h1>
<p><?php echo h($post['Post']['body'])?></p>
<p><small>Created: <?php echo $post['Post']['created']?></small></p>
Last modified on: <?php echo $post['Post']['modified']?></small></p>
</br>
<p>
<?php echo $html->link('back',array('action'=>'index'));?>
<?php echo $html->link('edit',array('action'=>'edit',$post['Post']['id']));?>
<?php echo $html->link('delete',array('action'=>'delete',$post['Post']['id']));?>
</P>
We’ll create it in the PostsController now:class PostsController extends AppController {
public function index() {
$this->set('posts', $this->Post->find('all'));
$this->set('title_for_layout','our blog title');
}
public function view($id) {
$this->Post->id = $id;
$this->set('post', $this->Post->read());
}
Go to index file and update
<!-- File: /app/View/Posts/index.ctp -->
<td>
<?php echo $this->Html->link($post['Post']['title'], array('action' => 'view', $post['Post']['id']));?>
</td>
Adding Posts
Reading from the database and showing us the posts is a great start, but let’s allow for the adding of new posts.
First, start by creating an add() action in the PostsController:
public function add() {
First, start by creating an add() action in the PostsController:
public function add() {
if (!empty($this->data)){
if ($this->Post->save($this->data)) {
$this->Session->setFlash('Your post has been saved.');
$this->redirect(array('action' => 'index'));
} else {
$this->Session->setFlash('Unable to add your post.');
} }
$this->set('title_for_layout','our blog title');
}
Here’s what the add() action does: if HTTP method of the request was POST, try to save the data using the Post model. If for some reason it doesn’t save, just render the view. This gives us a chance to show the user validation errors or other warnings.
Here’s what the add() action does: if HTTP method of the request was POST, try to save the data using the Post model. If for some reason it doesn’t save, just render the view. This gives us a chance to show the user validation errors or other warnings.
Every CakePHP request includes a CakeRequest object which is accessible using $this->request. The request object contains useful information regarding the request that was just received, and can be used to control the flow of your application. In this case, we use the CakeRequest::is() method to check that the request is a HTTP POST request.
When a user uses a form to POST data to your application, that information is available in $this->request->data. You can use the pr() or debug() functions to print it out if you want to see what it looks like.
We use the SessionComponent’s SessionComponent::setFlash() method to set a message to a session variable to be displayed on the page after redirection. In the layout we have SessionHelper::flash which displays the message and clears the corresponding session variable. The controller’s Controller::redirect function redirects to another URL. The param array('action' => 'index') translates to URL /posts i.e the index action of posts controller. You can refer to Router::url() function on the api to see the formats in which you can specify a URL for various cake functions.
Calling the save() method will check for validation errors and abort the save if any occur. We’ll discuss how those errors are handled in the following sections.
Data Validation
It will ensure that the data which your inserting is mantatory or not..something like * options
Data Validation
It will ensure that the data which your inserting is mantatory or not..something like * options
<!-- File: /app/View/Posts/add.ctp -->
<?php
echo $this->Form->create('Post');
echo $this->Form->input('title');
echo $this->Form->input('body', array('rows' => '3'));
echo $this->Form->end('Save Post');
?>
Editing Posts
First, start by creating an edit() action in the PostsController:
function edit($id = null) {
if (empty($this->data)){
$this->data = $this->Post->read(null,$id);
}
else {
if ($this->Post->save($this->request->data)) {
$this->Session->setFlash('Your post has been updated.');
$this->redirect(array('action' => 'index'));
} else {
$this->Session->setFlash('Unable to update your post.');
}
}
}
This action first checks that the request is a GET request. If it is, then we find the Post and hand it to the view. If the user request is not a GET, it probably contains POST data. We’ll use the POST data to update our Post record with, or kick back and show the user the validation errors.
The edit view might look something like this:
<!-- File: /app/View/Posts/edit.ctp -->
<h1>Edit Post</h1>
<?php
echo $this->Form->create('Post', array('action' => 'edit'));
echo $this->Form->input('title');
echo $this->Form->input('body');
echo $this->Form->input('id', array('type' => 'hidden'));
echo $this->Form->end('Save Post');
This view outputs the edit form (with the values populated), along with any necessary validation error messages.
One thing to note here: CakePHP will assume that you are editing a model if the ‘id’ field is present in the data array. If no ‘id’ is present (look back at our add view), Cake will assume that you are inserting a new model whensave() is called.
Go to index file and update
Go to index file and update
<!-- File: /app/View/Posts/index.ctp -->
<?php echo $this->Html->link('Edit', array('action' => 'edit', $post['Post']['id']));?>
</td>
Deleting Posts
Start with a delete() action in the PostsController:
function delete($id = null) {
$this->Post->delete($id) ;
$this->Session->setFlash('The post with id: ' . $id . ' has been deleted.');
$this->redirect(array('action' => 'index'));
}
}
Go to index file and update
<!-- File: /app/View/Posts/index.ctp -->
<td>
<?php echo $post['Post']['created']; ?>
<?php echo $this->Html->link('delete', array('action' => 'delete', $post['Post']['id']),NULL,'Are u sure u want to delete this post?');?>
</td>
Setting Routes
For some, CakePHP’s default routing works well enough. Developers who are sensitive to user-friendliness and general search engine compatibility will appreciate the way that CakePHP’s URLs map to specific actions. So we’ll just make a quick change to routes in this tutorial.
For more information on advanced routing techniques, see Routes Configuration.
By default, CakePHP responds to a request for the root of your site (i.e. http://www.example.com) using its PagesController, rendering a view called “home”. Instead, we’ll replace this with our PostsController by creating a routing rule.
Cake’s routing is found in /app/Config/routes.php. You’ll want to comment out or remove the line that defines the default root route. It looks like this:
<?php
Router::connect('/', array('controller' => 'pages', 'action' => 'display', 'home'));
This line connects the URL ‘/’ with the default CakePHP home page. We want it to connect with our own controller, so replace that line with this one:
<?php
Router::connect('/', array('controller' => 'posts', 'action' => 'index'));
This should connect users requesting ‘/’ to the index() action of our PostsController.
For better understanding go through online tutorials links are given below:
cakephp tutorial 2
cakephp tutorial 3
cakephp tutorial 4
cakephp tutorial 5
cakephp tutorial 6
cakephp tutorial 7
cakephp tutorial 8
No comments:
Post a Comment