MVC 3 : Create A Simple Blog Application Pt. 3

For those who missed my last tutorial on MVC on how to create simple blog application can try to review those by links listed below:

Part 1 – Create Simple Blog Application
Part 2 – Create Simple Blog Application
Part 3 - You are reading the tutorial at this moment
Part 4 - Create Simple Blog Application

On previous tutorial, I've cover much on how we develop our blog models using LightSpeed ORM and directly create the database to SQL. So in this tutorial I'll assume that we should have our models working. Previous tutorial did not mention on how we need to set the KeyTable for our database to allow LightSpeed to add new data on the same time add plus one to our Identity Table.

To accomplished this, we need to use the KeyTable SQL and run the query in SQL server management studio. Below is the SQL Query to insert the KeyTable:

IF EXISTS (SELECT * FROM sysobjects WHERE type = 'U' AND name = 'KeyTable')
BEGIN
  DROP TABLE KeyTable
END;
  
CREATE TABLE KeyTable
(
  NextId INT NOT NULL
)
  
INSERT INTO KeyTable VALUES (1);

After run the query, we should have another table named KeyTable. Once we have the table, we are done with designing our model on LightSpeed. Now we can start to work on Post.
On Post section, we should have the idea of what should be inside the Controller. This is the basic function that we should have on Post Controller that I can think of:

List All Post
Edit Post
Delete Post
Create New Post

So today I'll cover on all the function no Post. First we need to create the PostController in our Controller folder. To create a new controller, we can simply do the steps below:

Right click on Controller folder on Solution Explorer.
Select New Controller option
Name the Controller as 'PostController'
Click OK.

Now we should have our controller which we named as PostController. The file should be name as PostController.cs. Now we open the PostController.cs file and we delete all the content if it does have default template. We do not need to use any of the default code. So this is the code that we need for Post Controller:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using NegativeZero.Models;
using Mindscape.LightSpeed;
  
namespace NegativeZero.Controllers
{
    public class PostController : Controller
    {
        //
        // Declaring UnitOfWork to be used on the controller.  You could do it by declaring
        // it outside of the method, of it could be declared inside method. Both should work.
        LightSpeedContext context = new LightSpeedContext("Development");
        
        //
        // GET: /Post/
        [Authorize]
        public ActionResult Index()
        {
            using (var unitOfWork = context.CreateUnitOfWork())
            {
                var Post = unitOfWork.Find<Post>();
                return View(Post.ToList());
            }
        }
  
        public ActionResult Edit(int id)
        {
            using (var unitOfWork = context.CreateUnitOfWork())
            {
                var PostToEdit = unitOfWork.Find<Post>().Where(c => c.Id.Equals(id)).First();
                if (!PostToEdit.Equals(null))
                {
                    return View(PostToEdit);
                }
                else
                {
                    return View();
                }
            }
        }
  
        [HttpPost]
        public ActionResult Edit(string Id, string Title, string Author, string Posts, string Tag, string Categories)
        {
            using (var unitOfWork = context.CreateUnitOfWork())
            {
                var PostToEdit = unitOfWork.Find<Post>().Where(c => c.Id.Equals(Id)).FirstOrDefault();
                PostToEdit.Title = Title;
                PostToEdit.Author = Author;
                PostToEdit.Posts = Posts;
                PostToEdit.Tag = Tag;
                PostToEdit.Categories = Categories;
                unitOfWork.SaveChanges();
            }
            return Redirect("Index");
        }
  
        public ActionResult Create()
        {
            return View();
        }
  
        [HttpPost]
        public ActionResult Create(string Title, string Author, string Posts, string Tag, string Categories)
        {
            var data = new Post();
            if (Title.Length > 0 && Author.Length > 0 && Posts.Length > 0)
            {
                data.Title = Title;
                data.Author = Author;
                data.Posts = Posts;
                if (Tag.Length > 0)
                    data.Tag = Tag;
                else
                    data.Tag = null;
                if (Categories.Length > 0)
                    data.Categories = Categories;
                else
                    data.Categories = "Uncategorized";
                // Store data into SQL db
                using (var unitOfWork = context.CreateUnitOfWork())
                {
                    unitOfWork.Add(data);
                    unitOfWork.SaveChanges();
                }
                
                return Redirect("Index");
            }
            else
            {
                return View();
            }
        }
  
        public ActionResult Delete(int id)
        {
            using (var unitOfWork = context.CreateUnitOfWork())
            {
                var postToDelete = unitOfWork.Find<Post>().Where(c => c.Id.Equals(id)).Single();
                if (postToDelete.IsValid)
                {
                    unitOfWork.Remove(postToDelete);
                    unitOfWork.SaveChanges();
                }                    
            }
            return RedirectToAction("Index");
        }
    }
}

Once we have this code in our controller, we can now create our view. To create our view, MVC come with simple method. Below is the step to create our Viewing based on the Controller that we have built just now:

Right click on the method name. For example, method Index().
Select Add View.
Select strong view type option and select List.
On model option, we choose Post (NegativeZero.Models)

This step will automatically create view for you based on scaffold template that we select. For Index() method, we will use the List Scaffold as we would like to list all posted post by default. While on Edit() we will select Edit Scaffold to create a view that will allow author to edit the selected post. For Create() method, we use Create scaffold so that we could have plain form to make our new Post. Mean while, for Delete() method, I do not use any viewing since my controller will return the view to the Index action once the delete process success.

So, now we already half way done on finishing our project to create a simple blog application. On my next tutorial, I'll focus on comments.

Any question and suggestion are mostly welcome. Please like this post and drop comment(s) if you this this is useful.

Blogger Labels: Create,Simple,Blog,Application,tutorial,links,Part,database,Previous,KeyTable,data,Table,server,management,studio,Query,SELECT,FROM,WHERE,BEGIN,DROP,NextId,NULL,INSERT,INTO,VALUES,Once,Post,Controller,List,Edit,Delete,PostController,folder,steps,Solution,Explorer,option,Name,Click,template,code,System,Generic,Linq,NegativeZero,Mindscape,UnitOfWork,method,Both,LightSpeedContext,context,Development,Authorize,ActionResult,Index,CreateUnitOfWork,Find,View,ToList,PostToEdit,Equals,HttpPost,Title,Author,FirstOrDefault,SaveChanges,Redirect,Length,Single,IsValid,Remove,RedirectToAction,example,scaffold,Mean,action,comments,suggestion,Collections,Controllers,Categories,postToDelete

Thank you for your unbelievable support on Negative Zero - Permission to read and write blog for nearly 4 years. Don't forget to like Negative Zero on Facebook.

Mohammad Hafiz Ismail

Jul 3, 2011

MVC 3 : Create A Simple Blog Application Pt. 3

Post(s) you might like to read :

2 comments:

Recent Comments

MelayuBuntu

Negative Zero