ihostazure-post

5 Very Useful WordPress Trick

Today you can see numerous blogs and websites around you and there would be many blogs with unique features that you would like to have in your WordPress blog or site. However, it is not possible for everyone to know what they have to do to get unique features in their blogs or where to look for those features. This article will try to share some hacks and tricks that will be very useful for the WordPress development company and developers.

Set Custom Page as a Home Page in WordPress

This is the main feature that every developer wants to know where they can create their own design and set it as the home page of their blog. Create a new template or duplicate your PHP file as a template and log in to your WordPress admin panel. Publish your page and go to the option to select the custom homepage and point it to your newly created page. This is the simplest trick to have your custom designed page as your home page.

Create Page To Show Random Posts

This is the feature that is liked by every reader and developer. Web design company New Zealand have confirmed that all of their clients want this feature where their readers are shown random posts every time they refresh the page.

This is very simple method, first you have to create a custom page as mentioned above and then you have to add a simple WordPress Loop script that will show one post every time the page is refreshed. However, you have the option to increase the number of the posts.

Display External RSS feed in WordPress

Many times we see that bloggers display feeds of their other blogs on their site. This is the simplest trick to increase your traffic. Adding below mentioned codes anywhere in your theme will do the magic.

<?php echo ‘Posted ‘.$item->get_date(‘j F Y | g:i a’); ?>

Display Relative Dates

For the bloggers having good knowledge about the plugins of WordPress this is very simple job. All you have to do is download plugin called WP-Relative Date and activate the plugin. WordPress plugin development NZ are using this trick to please their clients.

News in a WordPress Site

This is the trick that is adapted by the top bloggers and sites to ensure that the useful section is displayed in the sidebar that is actually posted by the audience. This simple job can be accomplished by downloading plugin called TDO Mini Forms and activate it. There is no need of having any extra knowledge for this, just follow the instructions displayed and your site will be ready.

Hope the above mentioned tricks are useful for you.

ihostazure-post

Revealing Common Myths about WordPress Development

Like many other popular things, web design using WordPress also experiences myths getting associated with it for no strong reason. It is a challenging task for the developer to address these myths on a regular basis and filter out the small fraction of truth from the enormous amount of false conceptions. The main idea is to make sure that the performance and safety of the website is maintained.

Popular WordPress Development Myths Revealed

Numerous online stores uses WordPress development for their websites. Due to the prevalence of some myths there are still many individuals who hesitate integrating WordPress. Let us get into the depth of these myths and analyze how true they are:-

Website Speed is Slowed if WordPress Revisions Are Made

The various WordPress revisions never add to the slow performance of any website. MySQL database used usually manages all such revisions as in WordPress there occurs no provisions for revisions made at its front end. It is true that revisions do occupy some space inside the database but for standard users it causes no negative impact.

Usage of Plugins Slows Down The Website

There is a myth in the minds of certain people that using plugins given by WordPress slows down the site. WordPress plugin development company India clears the myth because the statement is valid only under certain cases. Only if a plugin is bulky in its weight then it can slow down the website if integrated within it. It can be noted that certain plugins are installed to speed up site performances.

Plugins Inactive Also Slows Down Site

Plugins which are used inside a WordPress website and are not in use can slow down the speed is another popular myth. It is not true. Inactive plugins do not affect speed. However, it is a healthy practice to uninstall plugins which have no usage to avoid weaknesses and security issues for the website. WordPress plugin development India does not update plugins which are inactive and hence can be a potential security threat.

Themes Not Active Slows Speed Down

Similar to the plugin myth, themes which are not in use do not slow down the site. Many times for WordPress customization India individuals use multiple themes. Many of these are not used as at one point of time WordPress can use only a single theme. However keeping unused items away is a good practice.

Trash Accumulation Affects Website Speed

WordPress engines have an inbuilt function to manage large trash amounts, comments, spams due to its interactive platform base. Hence, when trash occurs in WordPress it gets stored in the MySQL. This never affect the website’s loading time or speed.

ihostazure-post

ASP.NET MVC 4 Tutorial :: Creating Google Column Chart With Animation

In this tutorial, we will discuss about creating Google column chart with animation on load using ASP.NET MVC4 & Jquery. A column chart is a vertical bar chart rendered in the browser using SVG or VML, whichever is appropriate for the user’s browser. Like all Google charts, column charts display tooltips when the user hovers over the data. For a horizontal version of this chart, see the bar chart.

Steps :

1 – Create New Project.

Go to File > New > Project > Select asp.net MVC4 web application > Entry Application Name > Click OK > Select Internet Application > Select view engine Razor > OK

2 – Add a Database.

Go to Solution Explorer > Right Click on App_Data folder > Add > New item > Select SQL Server Database Under Data > Enter Database name > Add.

3 – Create table for get data for chart.

Open Database > Right Click on Table > Add New Table > Add Columns > Save > Enter table name > Ok.

In this example, I have used one tables as below

4- Add Entity Data Model.

Go to Solution Explorer > Right Click on Project name form Solution Explorer > Add > New item > Select ADO.net Entity Data Model under data > Enter model name > Add.
A popup window will come (Entity Data Model Wizard) > Select Generate from database > Next >
Chose your data connection > select your database > next > Select tables > enter Model Namespace > Finish.

5 – Add a new Controller.

Go to Solution Explorer > Right Click on Controllers folder form Solution Explorer > Add > Controller > Enter Controller name > Select Templete “empty MVC Controller”> Add.

6 -Add new action into your controller for Get Method.

Here I have added “Column” Action into “GoogleChart” Controller. Please write this following code

public ActionResult Column()

{

return View();

}

7 – Add view for the Action & design.

Right Click on Action Method (here right click on form action) > Add View… > Enter View Name > Select View Engine (Razor) > Check “Create a strong-typed view” > Select your model class > Add.

8 – Add jquery code for create google animated Chart.

<script>

$(document).ready(function () {

//Load Data Here

var chartData = null;

$.ajax({

url: '/GoogleChart/GetSalesData',

type: 'GET',

dataType: 'json',

data: '',

success: function (d) {

chartData = d;

},

error: function () {

alert('Error!');

}

}).done(function () {

drawChart(chartData);

});

});

 

function drawChart(d) {

var chartData = d;

var data = null;

data = google.visualization.arrayToDataTable(chartData);

 

var view = new google.visualization.DataView(data);

view.setColumns([0, {

type: 'number',

label: data.getColumnLabel(0),

calc: function () { return 0; }

}, {

type: 'number',

label: data.getColumnLabel(1),

calc: function () { return 0; }

}, {

type: 'number',

label: data.getColumnLabel(2),

calc: function () { return 0; }

}, {

type: 'number',

label: data.getColumnLabel(3),

calc: function () { return 0; }

}]);

 

var chart = new google.visualization.ColumnChart(document.getElementById('visualization'));

var options = {

title: 'Sales Report',

legend: 'bottom',

hAxis: {

title: 'Year',

format: '#'

},

vAxis: {

minValue: 0,

maxValue: 1000000,

title: 'Sales Amount'

},

chartArea: {

left:100, top: 50, width:'70%', height: '50%'

},

animation: {

duration: 1000

}

};

 

var runFirstTime = google.visualization.events.addListener(chart, 'ready', function () {

google.visualization.events.removeListener(runFirstTime);

chart.draw(data, options);

});

 

chart.draw(view, options);

}

google.load('visualization', '1', { packages: ['corechart'] });

</script>

 

9 – Add another new action into your controller for fetch json data for Chart.

Here I have added “GetSalesData” Action into “GoogleChart” Controller. Please write this following code

public JsonResult GetSalesData()

{

List<SalesData> sd = new List<SalesData>();

using (MyDatabaseEntities dc = new MyDatabaseEntities())

{

sd = dc.SalesDatas.OrderBy(a => a.Year).ToList();

}

 

var chartData = new object[sd.Count + 1];

chartData[0] = new object[]{

"Year",

"Electronics",

"Book And Media",

"Home And Kitchen"

};

int j = 0;

foreach (var i in sd)

{

j++;

chartData[j] = new object[] {i.Year, i.Electronics, i.BookAndMedia, i.HomeAndKitchen };

}

 

return new JsonResult {Data = chartData, JsonRequestBehavior = JsonRequestBehavior.AllowGet };

}

 

Complete View

@{

ViewBag.Title = "Column";

}

 

<h2>Column Chart With Animation</h2>

 

<br />

<div id="visualization" style="width:600px; height:300px">

 

</div>

 

<script type="text/javascript" src="https://www.google.com/jsapi"></script>

@section Scripts{

<script>

$(document).ready(function () {

//Load Data Here

var chartData = null;

$.ajax({

url: '/GoogleChart/GetSalesData',

type: 'GET',

dataType: 'json',

data: '',

success: function (d) {

chartData = d;

},

error: function () {

alert('Error!');

}

}).done(function () {

drawChart(chartData);

});

});

 

function drawChart(d) {

var chartData = d;

var data = null;

data = google.visualization.arrayToDataTable(chartData);

 

var view = new google.visualization.DataView(data);

view.setColumns([0, {

type: 'number',

label: data.getColumnLabel(0),

calc: function () { return 0; }

}, {

type: 'number',

label: data.getColumnLabel(1),

calc: function () { return 0; }

}, {

type: 'number',

label: data.getColumnLabel(2),

calc: function () { return 0; }

}, {

type: 'number',

label: data.getColumnLabel(3),

calc: function () { return 0; }

}]);

 

var chart = new google.visualization.ColumnChart(document.getElementById('visualization'));

var options = {

title: 'Sales Report',

legend: 'bottom',

hAxis: {

title: 'Year',

format: '#'

},

vAxis: {

minValue: 0,

maxValue: 1000000,

title: 'Sales Amount'

},

chartArea: {

left:100, top: 50, width:'70%', height: '50%'

},

animation: {

duration: 1000

}

};

 

var runFirstTime = google.visualization.events.addListener(chart, 'ready', function () {

google.visualization.events.removeListener(runFirstTime);

chart.draw(data, options);

});

 

chart.draw(view, options);

}

google.load('visualization', '1', { packages: ['corechart'] });

</script>

}

10 – Run Application.

 

ASP.NET MVC 6 Tutorial :: How to Search Record in MVC With Ajax and jQuery?

Today’s turotial is about how to search record in MVC with Ajax and jQuery. This code will filter out all matching records group by table column name.
hflnet52

First thing that you should do is create an empty ASP.NET MVC project. Now, add two class to your model. Employee and DemoContext and write the following code:

namespace SearchingDemo.Models
{
public class Employee
{
[Key]
public int Id { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public string Position { get; set; }
}
}
namespace SearchingDemo.Models
{
public class DemoContext : DbContext
{
public DbSet<Employee> Employees { get; set; }
}
}

Add a Home Controller. Now, Add index Action to controller. and create corresponding view.

public ActionResult Index()
{
return View();
}

Now, write the following code to Index View.
<link href="~/Content/Style.css" rel="stylesheet" />
<script src="~/Content/jquery-2.1.1.min.js"></script>
<script src="~/Content/CustomJs.js"></script>
<h2>Seaching Demo</h2>
<div class="divFind">
<table>
<tr>
<td>
<input type="text" id="txtSearch" />
</td>
<td>
<input type="button" id="btnSearch" value="Seach" />
</td>
</tr>
</table>
</div>
<div id="divList">
</div>

Write the .JS code for click event on seach button to get filtered result. add following .JS code.

$(document).ready(function () {
$('#btnSearch').on('click', function () {
var getkey = $('#txtSearch').val();
$.ajax({
type: 'POST',
contentType: 'application/json; charset=utf-8',
url: 'Home/Search',
data: "{ 'searchKey':' " + getkey + "' }",
success: function (data) {
BindData(data);
},
error: function (data) {
alert('Error in getting result');
}
});
});
});
function BindData(data) {
var ulList = '<ul>';
var resultType = ["FirstName", "LastName", "Position"];
$.each(data, function (i, d) {
ulList += '<li class="SeachType">' + resultType[i] + '</li>';
if (d.length > 0) {
$.each(d, function (key, value) {
ulList += '<li>' + value.FirstName + ' - ' + value.LastName + ' - ' + value.Position + '</li>'
});
} else {
ulList += '<li><span class="red">No Results</span></li>';
}
});
ulList += '</ul>'
$('#divList').html(ulList);
}

Javascript code calling search function, which is written in controller. Add search function to your controller.

public JsonResult Search(string searchKey)
{
DemoContext dbObj = new DemoContext();
var getKey = searchKey.Trim();
var getFirstName = dbObj.Employees.Where(n => n.FirstName.Contains(getKey)).ToList();
var getLastName = dbObj.Employees.Where(n => n.LastName.Contains(getKey)).ToList();
var getPostion = dbObj.Employees.Where(n => n.Position.Contains(getKey)).ToList();
IList<IList<Employee>> getTotal = new List<IList<Employee>>();
getTotal.Add(getFirstName);
getTotal.Add(getLastName);
getTotal.Add(getPostion);
int count = getTotal.Count();
return Json(getTotal);
}

 

HostForLIFE.eu ASP.NET MVC 6 Hosting
HostForLIFE.eu is European Windows Hosting Provider which focuses on Windows Platform only. We deliver on-demand hosting solutions including Shared hosting, Reseller Hosting, Cloud Hosting, Dedicated Servers, and IT as a Service for companies of all sizes. We have customers from around the globe, spread across every continent. We serve the hosting needs of the business and professional, government and nonprofit, entertainment and personal use market segments.

 

ihostazure-post

SQL Server 2014 Tutorial :: Deleting All SQL Database

In this tutorial, I will explain how to DROP or DELETE SQL Database. Let me show you how to empty and delete all SQL Database. Now write the following code snippet for Clear Blank SQL Database:

hflnet51

 

DECLARE @name VARCHAR(128)

DECLARE @SQL VARCHAR(254)

SELECT @name = (SELECT TOP 1 [name] FROM sysobjects WHERE [type] = 'P' AND category = 0 ORDER BY [name])

WHILE @name is not null

BEGIN

SELECT @SQL = 'DROP PROCEDURE [dbo].[' + RTRIM(@name) +']'

EXEC (@SQL)

PRINT 'Dropped Procedure: ' + @name

SELECT @name = (SELECT TOP 1 [name] FROM sysobjects WHERE [type] = 'P' AND category = 0 AND [name] > @name ORDER BY [name])

END

GO

/* Drop all views */

DECLARE @name VARCHAR(128)

DECLARE @SQL VARCHAR(254)

SELECT @name = (SELECT TOP 1 [name] FROM sysobjects WHERE [type] = 'V' AND category = 0 ORDER BY [name])

WHILE @name IS NOT NULL

BEGIN

SELECT @SQL = 'DROP VIEW [dbo].[' + RTRIM(@name) +']'

EXEC (@SQL)

PRINT 'Dropped View: ' + @name

SELECT @name = (SELECT TOP 1 [name] FROM sysobjects WHERE [type] = 'V' AND category = 0 AND [name] > @name ORDER BY [name])

END

GO

/* Drop all functions */

DECLARE @name VARCHAR(128)

DECLARE @SQL VARCHAR(254)

SELECT @name = (SELECT TOP 1 [name] FROM sysobjects WHERE [type] IN (N'FN', N'IF', N'TF', N'FS', N'FT') AND category = 0 ORDER BY [name])

WHILE @name IS NOT NULL

BEGIN

SELECT @SQL = 'DROP FUNCTION [dbo].[' + RTRIM(@name) +']'

EXEC (@SQL)

PRINT 'Dropped Function: ' + @name

SELECT @name = (SELECT TOP 1 [name] FROM sysobjects WHERE [type] IN (N'FN', N'IF', N'TF', N'FS', N'FT') AND category = 0 AND [name] > @name ORDER BY [name])

END

GO

/* Drop all Foreign Key constraints */

DECLARE @name VARCHAR(128)

DECLARE @constraint VARCHAR(254)

DECLARE @SQL VARCHAR(254)

SELECT @name = (SELECT TOP 1 TABLE_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE constraint_catalog=DB_NAME() AND CONSTRAINT_TYPE = 'FOREIGN KEY' ORDER BY TABLE_NAME)

WHILE @name is not null

BEGIN

SELECT @constraint = (SELECT TOP 1 CONSTRAINT_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE constraint_catalog=DB_NAME() AND CONSTRAINT_TYPE = 'FOREIGN KEY' AND TABLE_NAME = @name ORDER BY CONSTRAINT_NAME)

WHILE @constraint IS NOT NULL

BEGIN

SELECT @SQL = 'ALTER TABLE [dbo].[' + RTRIM(@name) +'] DROP CONSTRAINT [' + RTRIM(@constraint) +']'

EXEC (@SQL)

PRINT 'Dropped FK Constraint: ' + @constraint + ' on ' + @name

SELECT @constraint = (SELECT TOP 1 CONSTRAINT_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE constraint_catalog=DB_NAME() AND CONSTRAINT_TYPE = 'FOREIGN KEY' AND CONSTRAINT_NAME <> @constraint AND TABLE_NAME = @name ORDER BY CONSTRAINT_NAME)

END

SELECT @name = (SELECT TOP 1 TABLE_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE constraint_catalog=DB_NAME() AND CONSTRAINT_TYPE = 'FOREIGN KEY' ORDER BY TABLE_NAME)

END

GO

/* Drop all Primary Key constraints */

DECLARE @name VARCHAR(128)

DECLARE @constraint VARCHAR(254)

DECLARE @SQL VARCHAR(254)

SELECT @name = (SELECT TOP 1 TABLE_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE constraint_catalog=DB_NAME() AND CONSTRAINT_TYPE = 'PRIMARY KEY' ORDER BY TABLE_NAME)

WHILE @name IS NOT NULL

BEGIN

SELECT @constraint = (SELECT TOP 1 CONSTRAINT_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE constraint_catalog=DB_NAME() AND CONSTRAINT_TYPE = 'PRIMARY KEY' AND TABLE_NAME = @name ORDER BY CONSTRAINT_NAME)

WHILE @constraint is not null

BEGIN

SELECT @SQL = 'ALTER TABLE [dbo].[' + RTRIM(@name) +'] DROP CONSTRAINT [' + RTRIM(@constraint)+']'

EXEC (@SQL)

PRINT 'Dropped PK Constraint: ' + @constraint + ' on ' + @name

SELECT @constraint = (SELECT TOP 1 CONSTRAINT_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE constraint_catalog=DB_NAME() AND CONSTRAINT_TYPE = 'PRIMARY KEY' AND CONSTRAINT_NAME <> @constraint AND TABLE_NAME = @name ORDER BY CONSTRAINT_NAME)

END

SELECT @name = (SELECT TOP 1 TABLE_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE constraint_catalog=DB_NAME() AND CONSTRAINT_TYPE = 'PRIMARY KEY' ORDER BY TABLE_NAME)

END

GO

/* Drop all tables */

DECLARE @name VARCHAR(128)

DECLARE @SQL VARCHAR(254)

SELECT @name = (SELECT TOP 1 [name] FROM sysobjects WHERE [type] = 'U' AND category = 0 ORDER BY [name])

WHILE @name IS NOT NULL

BEGIN

SELECT @SQL = 'DROP TABLE [dbo].[' + RTRIM(@name) +']'

EXEC (@SQL)

PRINT 'Dropped Table: ' + @name

SELECT @name = (SELECT TOP 1 [name] FROM sysobjects WHERE [type] = 'U' AND category = 0 AND [name] > @name ORDER BY [name])

END

GO

 

Easy, right?
HostForLIFE.eu SQL Server 2014 Hosting

HostForLIFE.eu revolutionized hosting with Plesk Control Panel, a Web-based interface that provides customers with 24×7 access to their server and site configuration tools. Plesk completes requests in seconds. It is included free with each hosting account. Renowned for its comprehensive functionality – beyond other hosting control panels – and ease of use, Plesk Control Panel is available only to HostForLIFE’s customers. They offer a highly redundant, carrier-class architecture, designed around the needs of shared hosting customers.

ihostazure-post

Excellent Features from Microsoft Azure

Microsoft Azure is now popularly known as Windows Azure, the cloud computing platform that is developed by Microsoft for building, managing and deploying the applications and the services through the network of Microsoft data centers. It offers IaaS and PaaS services and supports various programming languages, frameworks and tools, including the third-party and Microsoft-specific software and systems.

Characteristics

Azure is the Microsoft’s cloud application platform. Recently in 2012, Azure came up with the following features:

• The websites allow the developers to build the sites by using PHP, ASP.NET, Python or Node.js, and can be distributed by using Git, FTP or Mercurial Server.

• The virtual machines allow the developers to travel from the infrastructure without changing the code, and thus can run the Linux machines and the Windows Server. Cloud services also support the automated deployments and multi-tier scenarios. Microsoft’s Platform Service is used in order to create extensive applications and services.

Data Management

The SQL Database, which was previously well-known as the SQL Azure Database, works to scale and extend applications in the cloud by using SQL server technology.

Media Services

Paas can be used for content protection, encoding, and streaming or analytics. The Microsoft Azure Platform offers an API built on the HTTP, REST and XML which allows the developer to connect with the services which is offered by Azure. Moreover, it also integrates with Git, Eclipse and Microsoft Visual Studio. It also provides the managed library class which epitomizes the functions of connecting with the services.

Other Services

Websites : It helps in the hosting of websites. The customers create the sites in ASP.NET, PHP, Python or Node.js and you can also select from various open source applications available in the gallery in order to deploy. This consists of an aspect of Platform as a Service (PaaS) offerings for the Azure.

Virtual Machines : The Azure virtual machines consist of Infrastructure as the service providing from Microsoft to the public cloud. As the preview, these machines supported the Windows Server 2008 and 2012 systems and distributors of Linux. The customers can also create the Virtual Machines, which they have control in order to run the Data Centers.

Cloud Services : The cloud computing services are the containers of the hosted applications. The applications are usually public web applications, like e-commerce solutions or websites. Developers write code, mainly for the cloud services in different programming languages. They can also be used in the private processing engines for some other work, like processing orders or the analyzing data. However, some of the software development kits are commenced by Microsoft for Java, Python and NET. The other languages support through the open source projects.

Implementation : Azure uses the specialized operating system known as Microsoft Azure in order to run “fabric layer”, which is hosted at Microsoft’s data centers, which manages the storage and computing resources of the computers and the provisions of the resources to the application running on the of Azure. Reliability and Scaling are controlled by the Azure Fabric Controller. The Microsoft Azure is described as the “cloud layer” on the Server Systems that use Windows Server 2008 and also the customized version of the Hyper-V, popularly known as the Azure Hypervisor in order to provide virtualization of the services. So, the environment and the services don’t crash if the server crashes within the data center and offers the management of the user’s web application, such as the load balancing and the memory resources.

Privacy : Microsoft Azure has stated, according to the USA Patriot Act, the US government has the access to the data ven though the hosted company is not American and the data resides outside the USA. Azure is a compliant with E.U. data Protection Directive. In order to manage the Security and Privacy related concerns, Microsoft has created the Microsoft Trust Center.

ihostazure-post

ASP.NET MVC 5 Tutorial :: Error Validation on Ajax

ASP.NET MVC 5 Tutorial

In computer science, data validation is the process of ensuring that a program operates on clean, correct and useful data. It uses routines, often called “validation rules” “validation constraints” or “check routines”, that check for correctness, meaningfulness, and security of data that are input to the system. The rules may be implemented through the automated facilities of a data dictionary, or by the inclusion of explicit application program validation logic.

hflnet51

If you’re developing rich web clients using Asp.net MVC on the back-end, you’ve probably come across this functionality that can be described with these conditions:

  1. client side data (may be a form),
  2. ajax posting of this data (form),
  3. controller action has strong type parameters,
  4. controller action processes data and returns anything but a full view (since it was an Ajax call)

Familiar? Then you’ve come across this problem: »What should be done when validation fails?«
Seems fairly straight forward, right? Well not so fast my fellow developer friend…

Old Fashioned

Validation in Asp.net MVC is really simple and very transparent. If you had to think about it all the time when developing Asp.net Web forms applications, you don’t have to do that with MVC anymore. Whenever your controller action takes strong type parameters and you define validation rules on the type itself, you can easily just lay back and watch the magic happen in front of your eyes.

When you don’t use Ajax (how old fashioned of you), your form will be posted back the usual way by means of browser reloading the whole page. Because browser reloads the whole page there will be some flickering since it will clear the window at a certain point to render the new response. So your application will have a master view (in terms of master/detail process), where the user could click some Add new link or button that will redirect them to the new entity view (the details view). This view presents a form where they enter relevant data and a button to submit it to server. Your controller action could look very similar to this:

[HttpPost]
public ActionResult Add(Person instance)
{
    if (!this.ModelState.IsValid)
    {
        // return the same view with validation errors
        return View(instance);
    }

    // save the new person instance and go back to master view
    Person result = this.Service.Add(instance);
    return RedirectToAction("Index");
}

Contemporary

But since we’re savvy web developers, we rather use asynchronous processing these days. Instead of asking the browser to post back data and reload the whole page, we rather issue an Ajax call. This way we avoid page flickering and even the nasty long page scroll position stays the same. Ajax FTW! All today’s desktop browsers support this functionality as well. Great way of doing it then.

The whole client process probably changed according to our advanced functionality. We’d still have the master view with the list of all entities, but clicking on the Add new link will most probably present a modal dialog box with the details form instead of redirecting the user to a whole new page. In terms of usability and interface comprehension, this is a much better experience. Something similar is frequently used in Sharepoint 2010 these days. The process would work like this:

  1. User clicks Add new link on the master view.
  2. Your javascript dims the master view and displays a dialog box with the new entity form (details view).
  3. User enters relevant data and clicks the Save link.
  4. Your javascript issues an Ajax call that posts back data.
  5. When everything goes according to the plan, server responds either with a PartialViewResult that holds visual representation of the newly created entity that can be appended to master page entity list, or JsonResult data that can be consumed for the same purpose (but you’ll have to manually transform JSON to visual HTML representation).
  6. Your javascript closes the dialog box.
  7. Master view is in full display again and your javascript adds the newly created entity to it’s list (while also providing some highlight animation).

It’s wiser to return a partial view since the same partial view can be used on the master view to display each entity item in the list, so they will be fully compatible and when you change your partial view, both functionalities still work as expected. Otherwise you’d have to change javascript code as well. Not DRY at all. This is our controller action now:

[HttpPost]
public ActionResult Add(Person instance)
{
    if (!this.ModelState.IsValid)
    {
        // we'll see this in a bit
    }

    // save the new person instance and go back to master view
    Person result = this.Service.Add(instance);
    return PartialView("Person", result); // or Json(result)
}

So what do we do, when user enters incorrect data into the form that’s not valid? You can’t just return some other partial view, because javascript expects something else. You could of course put additional functionality on the client side that would detect different HTML being returned, but that’s very prone to errors. Think of changing the partial view. Any of the two. DRY again. The best thing would actually be to return a 400 HTTP response and provide the right result in it. Why is this better?

  • Because it will keep working even when you completely redesign your views.
  • Because it’s going to be much easier to distinguish between a successful results and an erroneous one on the client.

If you’re an Asp.net MVC developer it’s highly likely that you use jQuery on the client. Distinguishing success from an error cannot be easier:

$.ajax({
    url: "Person/Add",
    type: "POST",
    data: $(this).serializeArray(), // provided this code executes in form.onsubmit event
    success: function(data, status, xhr) {
        // YAY! Process data
    },
    error: function(xhr, status, err) {
        if (xhr.status == 400)
        {
            // this is our erroneous result
        }
        else
        {
            // some other server error must have happened (most probably HTTP 5xx)
        }
    }
});

To make things reusable on the server side you have two possible (and most obvious) ways of doing it:

  1. Provide additional controller extension methods like PartialViewError, JsonError, etc. that will work very similar to their normal counterparts except they’ll also set the response status code to 400 (don’t forget to check whether this is an Ajax call, because if it’s not, don’t set status code).
  2. Provide a custom exception and an exception action filter that handles it.

The first one is quite trivial so I’ve decided to do the latter. And since I don’t use the usual pattern of displaying in-place form validation errors it also suits my needs.

Let’s first look at the code of my custom exception. It’s called ModelStateException because I throw it on invalid model state and it has a constructor that takes model state and gets the errors automatically from it. This is the code of the exception:

/// <summary>
/// This exception that is thrown when there are model state errors.
/// </summary>
[Serializable]
public class ModelStateException : Exception
{
    /// <summary>
    /// Gets the model errors.
    /// </summary>
    public Dictionary<string, string> Errors { get; private set; }

    /// <summary>
    /// Gets a message that describes the current exception and is related to the first model state error.
    /// </summary>
    /// <value></value>
    public override string Message
    {
        get
        {
            if (this.Errors.Count > 0)
            {
                return this.Errors.First().Value;
            }
            return null;
        }
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="ModelStateException"/> class.
    /// </summary>
    public ModelStateException() : base()
    {
        this.Errors = new Dictionary<string, string>();
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="ModelStateException"/> class.
    /// </summary>
    /// <param name="modelState">State of the model.</param>
    public ModelStateException(ModelStateDictionary modelState)
        : this()
    {
        if (modelState == null)
        {
            throw new ArgumentNullException("modelState");
        }

        //this.ModelState = modelState;
        if (!modelState.IsValid)
        {
            StringBuilder errors;
            foreach (KeyValuePair<string, ModelState> state in modelState)
            {
                if (state.Value.Errors.Count > 0)
                {
                    errors = new StringBuilder();
                    foreach (ModelError err in state.Value.Errors)
                    {
                        errors.AppendLine(err.ErrorMessage);
                    }
                    this.Errors.Add(state.Key, errors.ToString());
                }
            }
        }
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="ModelStateException"/> class.
    /// </summary>
    /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
    /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
    /// <exception cref="T:System.ArgumentNullException">
    /// The <paramref name="info"/> parameter is null.
    /// </exception>
    /// <exception cref="T:System.Runtime.Serialization.SerializationException">
    /// The class name is null or <see cref="P:System.Exception.HResult"/> is zero (0).
    /// </exception>
    protected ModelStateException(SerializationInfo info, StreamingContext context)
        : base(info, context)
    {
        if (info == null)
        {
            throw new ArgumentNullException("info");
        }

        // deserialize
        this.Errors = info.GetValue("ModelStateException.Errors", typeof(Dictionary<string, string>)) as Dictionary<string, string>;
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="ModelStateException"/> class.
    /// </summary>
    /// <param name="message">The message.</param>
    public ModelStateException(string message)
        : base(message)
    {
        this.Errors = new Dictionary<string, string>();
        this.Errors.Add(string.Empty, message);
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="ModelStateException"/> class.
    /// </summary>
    /// <param name="message">The message.</param>
    /// <param name="innerException">The inner exception.</param>
    public ModelStateException(string message, Exception innerException)
        : base(message, innerException)
    {
        this.Errors = new Dictionary<string, string>();
        this.Errors.Add(string.Empty, message);
    }

    /// <summary>
    /// When overridden in a derived class, sets the <see cref="T:System.Runtime.Serialization.SerializationInfo"/> with information about the exception.
    /// </summary>
    /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
    /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
    /// <exception cref="T:System.ArgumentNullException">
    /// The <paramref name="info"/> parameter is a null reference (Nothing in Visual Basic).
    /// </exception>
    /// <PermissionSet>
    ///     <IPermission class="System.Security.Permissions.FileIOPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Read="*AllFiles*" PathDiscovery="*AllFiles*"/>
    ///     <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="SerializationFormatter"/>
    /// </PermissionSet>
    [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]
    public override void GetObjectData(SerializationInfo info, StreamingContext context)
    {
        if (info == null)
        {
            throw new ArgumentNullException("info");
        }

        // serialize errors
        info.AddValue("ModelStateException.Errors", this.Errors, typeof(Dictionary<string, string>));
        base.GetObjectData(info, context);
    }
}

The exception action filter has to intercept ModelStateException exceptions and return the error in a predefined format, so the client’s able to uniformly consume it. This is the code that I’m using:

/// <summary>
/// Represents errors that occur due to invalid application model state.
/// </summary>
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, AllowMultiple = false)]
public sealed class HandleModelStateExceptionAttribute : FilterAttribute, IExceptionFilter
{
    /// <summary>
    /// Called when an exception occurs and processes <see cref="ModelStateException"/> object.
    /// </summary>
    /// <param name="filterContext">Filter context.</param>
    public void OnException(ExceptionContext filterContext)
    {
        if (filterContext == null)
        {
            throw new ArgumentNullException("filterContext");
        }

        // handle modelStateException
        if (filterContext.Exception != null && typeof(ModelStateException).IsInstanceOfType(filterContext.Exception) && !filterContext.ExceptionHandled)
        {
            filterContext.ExceptionHandled = true;
            filterContext.HttpContext.Response.Clear();
            filterContext.HttpContext.Response.ContentEncoding = Encoding.UTF8;
            filterContext.HttpContext.Response.HeaderEncoding = Encoding.UTF8;
            filterContext.HttpContext.Response.TrySkipIisCustomErrors = true;
            filterContext.HttpContext.Response.StatusCode = 400;
            filterContext.Result = new ContentResult {
                Content = (filterContext.Exception as ModelStateException).Message,
                ContentEncoding = Encoding.UTF8,
            };
        }
    }
}

Reusable End Result

All our controller actions can now take advantage of this reusable functionality. The previously shown controller action now looks like this:

[HttpPost]
[HandleModelStateException]
public ActionResult Add(Person instance)
{
    if (!this.ModelState.IsValid)
    {
        throw new ModelStateException(this.ModelState);
    }

    // save the new person instance and go back to master view
    Person result = this.Service.Add(instance);
    return PartialView("Person", result);
}

Our client side functionality can now be packed into a simple application specific jQuery plugin that does ajax error handling and can be loaded as part of the general scripts on your master (as in master template) view:

$.extend({
    appAjax: function(url, type, datagetter, onsuccess) {
        /// <summary>jQuery extension that executes Ajax calls and handles errors in application specific ways.</summary>
        /// <param name="url" type="String">URL address where to issue this Ajax call.</param>
        /// <param name="type" type="String">HTTP method type (GET, POST, DELETE, PUT, HEAD)</param>
        /// <param name="datagetter" type="Function">This parameterless function will be called to return ajax data.</param>
        /// <param name="onsuccess" type="Function">This optional function(data) will be called after a successful Ajax call.</param>

        var execSuccess = $.isFunction(onsuccess) ? onsuccess : $.noop;
        var getData = $.isFunction(datagetter) ? datagetter : function() { return datagetter; };

        $.ajax({
            url: url,
            type: type,
            data: getData(),
            error: function(xhr, status, err) {
                if (xhr.status == 400)
                {
                    alert(xhr.responseText);
                }
                else
                {
                    alert("Server error has occured.");
                }
            },
            success: function(data, status, xhr) {
                window.setTimeout(function() {
                    execSuccess(data);
                }, 10);
            }
        });
    }
});

In your page, you can simply call it this way:

$.appAjax(
    "Person/Add",
    "POST",
    function() { return $(this).serializeArray(); },
    function(data) { // consume data }
);

This is the reusable model validation in Asp.net MVC applications using Ajax calls and jQuery on the client side.

HostForLIFE.eu ASP.NET MVC 5 Hosting
HostForLIFE.eu revolutionized hosting with Plesk Control Panel, a Web-based interface that provides customers with 24×7 access to their server and site configuration tools. Plesk completes requests in seconds. It is included free with each hosting account. Renowned for its comprehensive functionality – beyond other hosting control panels – and ease of use, Plesk Control Panel is available only to HostForLIFE’s customers. They offer a highly redundant, carrier-class architecture, designed around the needs of shared hosting customers.

image

ihostazure-post

ASP.NET Vs Classic ASP.NET | Which One More Powerful?

Microsoft entered the arena of dynamic web sites with ASP (Active Server Pages) about a decade ago. ASP allowed you to “actively” change the web pages served to the client depending on your needs. ASP worked (and still works) very well for basic web design. It requires a Microsoft based IIS server and the necessary licenses.

ASP.NET is Microsoft’s next evolution for server driven web pages. Rather than amend ASP to add new functionality, ASP.NET is a complete overhaul providing a programming interface that allows developers familiar with Visual Basic and other Microsoft based client-server development tools to code for the internet.

ASP.NET is superior to ASP Classic. There are four main areas that make ASP.NET a much better choice for programmers. These four areas include: stability, performance, scalability and language support.

Stability

ASP is running under the inetinfo.exe (IIS) process space, making it susceptible to application crashes. This happens because the IIS needs to be stopped or restarted on a regular basis. The ASP.Net process is separate from inetinfo.exe, meaning that it is not susceptible to these types of application crashes. This means that the final product will be much more stable.

Compilation

ASP Classic is comprised of VBScript or Jscript interpreted at run-time which means each page has a specific performance hit due to line by line interpretation. The interpretation of the pages simply results in some inefficiency.

ASP.NET however compiles the code the first time it is accessed. The compiled code results in .NET classes housed within assemblies and allow subsequent page requests to be serviced with previously compiled code. ASP.NET therefore inherently provides a more secure and largely efficient rendering model by incorporating compilation and specifically the reuse of the compiled code. This ultimately means a better experience for the end user.

Scalability

With Classic ASP applications, components used by pages are fairly difficult to update, maintain or replace. In general updating a component in a running application will require the shutting down of IIS, replacement of the component and finally a restart of IIS.

ASP.NET was built to provide specific enhancements that allow scalable and efficient application updating. The ‘xcopy’ deployment model of .NET allows replacement of pages and components in real time and does not require a restart of the web server. If an update needs to be made to a current production application, developers can simply make the change and the infrastructure can account for that change the next time a request is made to the altered page or component. This means that content updates, fixes and enhancements to ASP.NET applications can be made in real time with little to no impact to the user base.

Language Support

ASP.NET supports full server side programming languages and not just scripting languages. Only VBScript and Javascript are available for scripting in ASP Classic where as, in ASP.NET there are no such restrictions. With ASP.NET several programming languages like C# and VB.NET are available to program in accordance to the developers preference where both of them can even be used in the same application. The benefits of using server side programming languages can be seen in the previously mentioned compilation of code and the fact that rich control sets and complex frameworks are available to applications. In summary, the language support of ASP.NET allows for the development of robust, feature rich applications with deep programmatic support.

ihostazure-post

5 Simple Steps to Install Joomla

There are two popular ways to upload and install Joomla on your website. The first (and simplest) is using the automated Joomla installation feature that your web hosting service provider may have activated on your “Control Panel”. The second way to upload Joomla and install it is to do it manually. This may seem kind of difficult initially, but it is very simple, if you understand how. In either of the two cases, you must have a web hosting account and be able to access it to be able to go ahead. You can’t use a free blog hosting account (Blogspot, etc) to do this. Below, I will give you a step by step blueprint for uploading and installing Joomla manually in 5 minutes or less. Here we go:

1. Download Joomla: The first step would be to of course download the latest Joomla installation package. You can do this by visiting Joomla.org and following the instructions to download the Joomla package.

2. Create a Joomla Installation Database: Now, login to your Joomla web hosting account and open the MySQL database creation and management program. A list of your databases and database user details are in the MySQL area of your Control Panel. Now, you should create a database and a username and password to go with it. Next, add the username to the database and give it all the privileges. This is simple as the interface is easy to follow. (But you can also watch the video instead if that is preferable to you.) This user ID and password and its database are what you will use to install Joomla on your website.

3. Upload Joomla: The next step is to determine where you want the Joomla installation to be and upload it to that. If you want to install Joomla on the main website/full domain name (eg mywebsite.com, etc), then you should go to the home directory and upload Joomla to it.

4. The Actual Joomla Installation: This is the simplest and most self-fulfilling part of the whole process. But you should also be careful not to make mistakes here or you may never be able to install the Joomla software correctly. You should also take note of the Joomla admin user name and password that you create during this process, to prevent losing access to your account. During the Joomla installation, you will put in such details as the name of the database that you created in step #2 and the username and password that you attached to it. You will put in the name and title of your website (great for Joomla SEO) and your email address to be used as the admin email in case you forget your Joomla admin login username and password. I would advise that you save all your login details in a secure place (like a random file on your computer or your brain [yeah, memorize it!] ) to avoid discomfort later on when you start the business of designing your Joomla website.

5. Finish: Yes, that’s it! You have just finished uploading and installing Joomla on your website! Now head on to the /administrator directory of the website where you installed Joomla (eg mywebsite.com/administrator ) and use the login ID and password that you created during the installation process to login to your Joomla website for the first time. How does it look in there?

ihostazure-post

60 Free and Useful WordPress Plugin

The best WordPress plugins can enhance your blog with many exciting features to help expand your online presence, interact with your readers, and increase your blogging revenue. WordPress plugins are essential to take full advantage of the WordPress blogging platform, and these are some of the best WP plugins in a variety of categories. Take advantage of these WordPress plugins to enhance your WordPress blog with exciting new features.

WordPress Optimization

Optimization plugins help increase your natural traffic and create a better SEO presence.

  • Platinum SEO Pack
  • Greg’s High Performance SEO
  • WordPress SEO by Yoast
  • SEO Ultimate

WordPress Links

Link plugins help you manage and organize your links to provide a better reader experience and SEO optimization.

  • SEO Smart Link
  • Broken Link Checker
  • WP Render Blogroll Links

WordPress Comments

Comment plugins help you increase reader comments and interaction between readers with enhanced comment features.

  • IntenseDebate Comments
  • Disqus Comment System
  • Facebook Comments for WordPress
  • Comment Rating

WordPress Email Subscriptions

Email subscription plugins allow you to provide your readers with email subscriptions and send out newsletters.

  • MailChimp List Subscribe Form
  • Constant Contact for WordPress
  • AWeber Web Form Plugin
  • WP Email Capture
  • Subscribe2

WordPress Membership Communities

Membership community plugins for users allow you to build active communities to help grow your blog.

  • s2Member
  • Mingle
  • WP-Members

WordPress Social Media

Social media plugins allow your readers to promote your articles through a variety of social networks for free publicity.

  • Sexy Bookmarks
  • Simple Facebook Connect
  • WP Tweet Button

WordPress Forms

Forms plugins make it easier for your readers to contact you and more efficient for you to manage your inquiries.

  • Contact Form 7
  • Fast Secure Contact Form
  • Custom Contact Forms
  • Formiddable Forms

WordPress Polls

Polls plugins allow you to interact with your readers through polls and surveys.

  • SodaHead Polls
  • PollDaddy Polls and Ratings
  • WP Polls

WordPress Ratings

Ratings plugins allow bloggers to add reader rating systems to WordPress blogs.

  • Comment Rating
  • GD Star Rating
  • Star Rating for Reviews

WordPress Donations

Donation plugins are perfect if you want to request and process donations from your visitors.

  • PayPal Donations
  • Donation Can
  • Donate Plus
  • Mingle Donations Button

WordPress Videos

Video plugins make it easy to implement videos on your WordPress blog.

  • VideoPress
  • All-in-One Video Pack
  • WordPress Video Plugin
  • Stream Video Player
  • MediaElement.js
  • Embedded Video

WordPress Audio

Audio plugins help you provide the best quality audio and present it in a simple way to your listeners.

  • Audio Player
  • MediaElement.js – HTML5 Video & Audio Player
  • Audio Player Widget
  • Audio Link Player

WordPress Images and Galleries

Images and galleries plugins help you display your images or galleries in an interactive way for your viewers.

  • NextGen Gallery
  • Page Flip Image Gallery
  • WP Photo Album Plus
  • Flickr Photo Album
  • SEO Friendly Images

WordPress Health

Health plugins monitor the health of your WordPress installation to protect your WP site from security vulnerabilities, attacks, and spammers.

  • WP Security Scan
  • Akismet

WordPress Backups

Backup plugins help you automate the task of making regular backups of your WordPress site.

  • EZPZ One Click Backup
  • WordPress EZ Backup
  • XCloner – Backup and Restore

WordPress Translations

Translation plugins help you expand your international web presence with language translation features.

  • Global Translator
  • Google Ajax Translation
  • Transposh
  • qTranslate

Use these WordPress plugins to enhance your blog and increase your readership.