JavaScript for Line of Business Applications

MVC4Bootstrap3Sample is an Asp.NET MVC4 project using Bootstrap3 as its theme. To use it download the project file from my Github repository and open the solution in Visual Studio.NET 2012. This repository's bootstrap3 is not added by using Nuget.

In this article we will learn to write mobile apps using native, hybrid and responsive development techniques for popular device platforms like iOS & Windows Phone for now and later Android & Black Berry.

The summary of the topics covered:

iOS Native App -> with Intro to Objective-C
Windows Phone Native App -> with Pricing, Device Overview and VS2012 Windows Phone Project
Mobile App Development - Possible Paths -> Native, Hybrid, HTML5
Hybrid Mobile App -> with PhoneGap, jQuery Mobile, KendoUI Mobile, Sencha Touch, HTML 5 Responsive Website

We will build two types of data-grids (tables) in this article:
* One with AJAX based paging and sorting for displaying large number of records
* One with JavaScript based (no-postbacks/AJAX calls) paging and sorting for lesser number of records

In both of the above we want the following:
* Reusable, extensible, and maintainable JavaScript code
* Use Knockout JS (KO)

We would display a list of students, their age, school name, and school address in a data-grid (as shown in the image above).

In this article, I want to demonstrate the use of KO and some basic object oriented JavaScript. There are other good articles on CodeProject demonstrating, for example, the use of jqGrid with MVC 4. However here we will develop the entire data-grid (with paging/sorting functions) to have better control over the generated output.

Though I have used ASP.NET MVC 4 as backend to this project, other technologies (PHP etc.) can be used as well, as the client side code to generate data-grid is agnostic of backend technology. I will keep explaining any particular JavaScript constructs that are a bit tricky for users having only basic knowledge of JavaScript.

This article uses ASP.NET Web API and Knockout JS to implement Templating and Data Binding and applies it to a common Line of Business application requirement – Paging and Sorting a Grid

Knockout JS as we know is a highly versatile JavaScript library that helps us implement the MVVM pattern on the client by providing us with two way data binding and templating capabilities. Today we will use Knockout JS and ASP.NET Web API to build an application that represents data in a tabular format with AJAX based sorting and paging capabilities.

Representing Tabular data in a table is as old as web itself and today end users expect a certain amount of features and functionality built in. These include fast access, sorting, paging and filtering. There are well established libraries like Datatables.net that already do these for us. However, knowing how something is implemented, helps us tweak things to our advantage, because no two requirements are the same, ever.

Here’s how to create a complete web app in under an hour. We will (naturally!) create a todo app. The features:
* Create, update, delete a todo
* Sort (and show sort order)
* Search
* Pagination

We’ll try to make it somewhat user friendly, e.g.
* Date-picker widget for todo due date
* Enable/disable buttons as appropriate for context

Our infrastructure will be:
* Backend Language: C#
* Backend Framework: WebApi
* Database: SQL Server (including SQL Express LocalDB during development)
* ORM: Entity Framework Code First + Migrations
* Frontend Framework: AngularJS
* CSS styles: Bootstrap
* IDE: Visual Studio + Resharper
* Hosting: Appharbor

As you’ll see, this particular choice of tools is well suited to rapid application development, and is also very flexible.
The goal is not just to throw together the minimal necessary to have something working, but to create a really flexible infrastructure that we can use as a foundation for many future applications. OK, let’s get started.

Today we will revisit Directives in an attempt to make them more self-contained and re-usable.

In our previous Routing article, we had created a new separate Controller for our Status page called the StatusController. But unfortunately we found out that our Retweet Directive was broken in the Details page because the button click handler that was doing the actual Retweet action was in the TimelineController. This led us to abandon the StatusController and stuff everything back into TimelineController. That was an ugly hack. After all we want the Retweet functionality to be self-contained and reusable. Let’s see how we can do this.

Fortunately there is one concept about Directives that we haven’t visited yet and that is Directive specific controllers. Yup, directives can have their own controllers as well. Today we’ll see how to use this concept of modularize our Retweet button Directive.

n a previous post, we saw how to create a minimal ASP.NET WebApi project template, so that we can avoid some of the bloat and complexity inherent in the standard VS WebApi project. Getting started building out an API project using the minimal project template is much easier, and we can always add back stuff as our project grows.

For starters, though, the minimal project makes it much easier to focus on our principle task – creating a simple, clean API. This minimal project is especially useful if, like myself, you are less-than-experienced, and learning your way through Web API development. Or, if you just want a simple project.

In building our example, we will adhere to what are recommended conventions for an MVC project. While we are not creating a website proper, it will serve us well to follow the conventions designed into the MVC framework (of which WebApi is a part). Note how I have set up the basic project, with a Models folder and a Controllers folder (at this point, we don't need Views). If you have worked with a standard ASP.NET MVC project before, this part should look pretty familiar.

Creating a chart to display real-time updates using native HTML5 push notification (Server-Sent event) and ASP.NET Web API.

In this article, we’ll create a chart to display real-time updates using native HTML5 push notification. The HTML5 Server-Sent event (SSE) model allows you to push real-time data updates from the server to the browser. 

Here, our objective is to get random number at random time interval from server and plot the chart.

To start receiving server notifications, we simply open a connection to an SSE URI and setup our callbacks in javascript...

In this post we take a look at the slight mind shift that ASP.NET MVC developers working on JavaScript and jQuery face when they first start using KnockoutJS.

Knockout JS is a fantastic library when you are looking for a drop-in enhancement that brings in client side data-binding and elements of the MVVM design pattern into your website that’s a potpourri of Razor syntax, server side Html Helpers and jQuery plugins.

Well Knockout JS was built to bring meaning into this chaos, but before you get started, you have to detune yourself a bit. Let’s see what that means. By the way, this article assumes you have the KO cheat-sheet created by Sumit Maitra handy so that you can quickly lookup some of the syntax we throw around. Sumit has helped me a great deal in co-authoring this article and just like an AngularJS +  MVC series, we are planning to collaborate to do a KnockoutJS series too.

Heavily drawing inspiration from Ruby on Rails, MVC4’s convention over configuration model of development soon became the Holy Grail of .NET web development. The MVC model brought with it the goodness of proper separation of concerns between business logic, data, and the presentation logic.

However, the MVC paradigm, was still one in which server side .NET code could be mixed with presentation code. The Razor templating engine, though cleaner than its predecessors, still encouraged and allowed you to mix .NET server side code with presentation logic.

Mixing .NET code with HTML in views can soon get very messy. Wouldn’t it be nice if the presentation layer (HTML) could be pure HTML? Also, in the ASP.NET MVC model, some of the business logic invariably resides in the controller. It is tempting to use an anti­pattern like the one shown above to control whether a div should be shown or not.

However, best practice would indicate that the Controller should not be aware of the div. The ShowDiv variable in the model should not exist. A controller should ideally, only be used to do the plumbing of getting the data populated in the model and nothing else. The view (ideally pure HTML) should render the presentation layer based on the model.

In this article we will see how Angular JS, a new JavaScript framework by Google can be used effectively to build web applications where:

1. Views are pure HTML

2. Controllers (in the server sense) are pure REST based API calls

3. The presentation layer is loaded as needed from partial HTML only files.

Here’s how I built a quick single entity CRUD grid with AngularJS, WebAPI, Entity Framework, Bootstrap, Font Awesome & Toastr.  I spent a more time than I should have getting this all wired up, so I thought I’d share the code to save you some time. 

This project is an application skeleton for a simple AngularJS app. You can use it to bootstrap you AngularJS web application projects in Visual Studio environment.

This seed contains AngularJS libraries, test libraries and a bunch of scripts all preconfigured for instant web development gratification. Just clone the repo (or download the zip/tarball), open it in Visual Studio 2012 and you are ready to develop and test your web application.

This seed doesn't do much, just shows how to write two controllers and views together. You can check it out by running App project in Visual Studio.

Technologies:

* AngularJS MV* family JavaScript Framework
* ASP.NET Web Api library for building RESTful services
* ASP.NET Web Pages adds Razor syntax to your HTML views
* ASP.NET Web Optimization Framework bundles and minifies JavaScript/CSS files
* TypeScript adds static typing to JavaScript and better IDE goodies
* LESS CSS extends CSS with dynamic behavior

The goal of this article is to walk through a sample Customer Maintenance web application that implements the latest technology from the Microsoft stack, including the latest beta versions of Microsoft .NET 4.5.1, Visual Studio Express 2013, MVC5, WebAPI 2 and Entity Framework 6. 

Throughout this article various design patterns and techniques will be implemented to help foster a loosely coupleddesign that promotes the Separation of Concerns (SoC) through the various layers of an n-tier web application. Overall the implementation of this sample application is a variation of my previous Code Project article MVC Techniques with jQuery, JSON, Knockout, and C#. 

This article presents a custom control that allows to easily create a data-bound an HTML Table to a remote, server-side ObservableCollection:

* An ObservableCollection is used on the server in order to notify remote clients of updates.
* It uses knockout.js library for client-side databinding.
* It uses websockets internally, but abstracted by Spike-Engine, will fallback to flash sockets for older browsers.
* It is cross-platform and with a minimized packet payload and message compression.
* The application server is a self-hosted executable and the client is just a plain HTML file.

Few weeks before writing this article I had an interesting idea, I wanted to abstract client-server networking and create a nice API that would maintain an HTML Table automatically populated by being data-bound remotely on an ObservableCollection. Essentially, allowing data-bound views be updated in real-time whenever a change occurs and a new item is added or removed from the collection. This would allow people to build seamlessly and easily very dynamic and great looking websites, providing users with a great user experience.

We take a look at how to use TypeScript’s definitions for KnockoutJS to build a small ASP.NET MVC application. Along the way we explore the TypeScript language and gauge how it can be potentially used for build ASP.NET MVC applications that lean on the client side JS Libraries for richness and interactivity.

* Getting Started with TypeScript in Visual Studio 2013 Preview
* TypeScript in ASP.NET MVC
* The Task Listing App in TypeScript
* Setting up our Knockout ViewModel using TypeScript
* Updating View to use client side bindings
* Summarizing our TypeScript code

In this article, we will explore how we can use the jQuery Validator in an ASP.NET MVC application that uses Knockout Templating. Traditionally, jQuery validator works out of the box with KO ViewModels that are statically bound.

But there are a couple of additional things that you’ve to do when templates are involved and the DOM is manipulated on the fly.

Today we use a slightly different harness from the first two parts because we need validations for the dynamic controls added by the template.