Archive for the ‘’ Tag

Syncronizing time/watch between javascript client and ASP.NET MVC 4 server

I just wished working with Date() in Javascript was easier.
Recently here at 4N1, we had to make some date-time calculations on the client-side of a web application. The app arquitecture is:

Client side

  • Html 5: Just added the 5 to look cool. 😀
  • Javascript: You know what that is.
  • Knockout JS: An amazing Javascript MVVM framework.
  • TaffyDB: An awesome Javascript database.

Server side

Since the client and the server time can be different, we need a way to know exactly how much it is to adjust our calculation. Talking with an old colleague, Rui Milagaia, the following solution came up:

Time sync Logic

A device is anything that has a time. This logic can be applied in any scenario(computer A to computer B, client to server, server to server, device A to device B, etc).

NOTE: This solution will not guarantee milliseconds precision but if your doing calculations that go only down to the second, it should be ok.

Back to our app, since is javascript, I’ve used jquery to perform an ajax request to an MVC Action. I just needed to guarantee that the request was synchronous, otherwise the asynchronous behavior adds noise to the calculated value. I’ve created a github repository with the source code here. You can use it with another server side technologies (JSP, Rails, Grails, etc). Here is the important steps:

Client side

  1. Add a reference to the 4n1.timesync.js file:
    <!-- jQuery 1.5 or later is a foranyone.timeSync dependency -->
    <script src="jquery-1.6.4.js" type="text/javascript"></script>
    <!-- Reference to the 4n1.timeSync script file-->
    <script src="4n1.timeSync.js" type="text/javascript"></script>
    <!-- To make it easier to parse date strings with the ISO 8601 format, we use the library from -->
    <script src="iso8601.js" type="text/javascript"></script>
  2. Set the expected properties, in my case only the url to the MVC Action, and call the foranyone.timeSync.getTimeDifference function to retrieve the time difference in milliseconds.

    foranyone.timeSync.url = "";
    // This variable now has the difference from the client and the server in milliseconds. It can be positive or negative.
    var timeDifference = foranyone.timeSync.getTimeDifference();
  3. Server side

    1. Just implement an action that returns the server time:
      public class ServerTimeController
          public ActionResult GetServerTime()
              // Using a Iso format string without all the milliseconds because IE cannot process it :p. 
              return Json(DateTime.Now.ToString("yyyy'-'MM'-'ddTHH':'mm':'ss.fff%K"), JsonRequestBehavior.AllowGet);

    And thats it. Happy syncronization! 😀


ASP.NET MVC4/Upshot/Knockout: Remote + Local DataSource

The SPA (Single Page Application) I’m creating, does not sync all the changes with the server using the upshot RemoteDataSource. Because of that, I had to use a mixed approach, that is, a RemoteDataSource plus a LocalDataSource. The remote one brings the data from the server, while the local is used to make changes that will update the User interface, without going to the server. Here is the code:

// Used to "construct" new Model instances
function Model(data) {
	var self = this;

	// add properties from the JSON data result, "SomeEntity:#SomeNamespace", self);

	// add properties managed by upshot

function ViewModel() {

	self = this;

	// Code generated by the Server-side @(Html.UpshotContext(true).DataSource<SomeNamespace.EntitiestController>(x => x.GetEntities()))
	upshot.metadata({ "SomeEntity:#SomeNamespace": { "key": ["Id"], "fields": { "Id": { "type": "String:#System" } }, "rules": {}, "messages": {}} });

	upshot.dataSources.Items = upshot.RemoteDataSource({
		providerParameters: { url: "/api/Entities?action=", operationName: "GetEntities" },
		entityType: "SomeEntity:#SomeNamespace",
		bufferChanges: true,
		dataContext: undefined,
		mapping: {}

	// Creates a reference to the items returned by the remote datasource
	self.dataSource = upshot.dataSources.Items.refresh();

	// Create a local datasource that references the items returned by the remote datasource
	self.localDataSource = upshot.LocalDataSource({ source: self.dataSource,
		autoRefresh: true, allowRefreshWithEdits: true

        // Creates a filter to hide the deleted items (Since we are not syncing the changes, they will keep appearing on the UI otherwise)
        self.localDatasource.setFilter({ property: 'IsDeleted', value: false, operator: '==' });

	// Creates a reference to the local datasource entities to use it on the UI binds
	self.items = self.localDataSource.getEntities();

	self.addNew = function () {

		// Create a new item
		var item = new Model(null);

		// Pushes the item to the list of items. This will update the UI

	self.remove = function (item) {
		// Removes the item from the localDatasource

		// To update the UI, you have to refresh the local datasource (don't know why it does not do automatically)

The autoRefresh property is self-explanatory. The important one here is the allowRefreshWithEdits property, that will allow us to execute refresh’s on the local datasource while having changes (it triggers an error if you don’t do this).

Another important thing is to add a filter to hide all the deleted entities at the local datasource. Since they are not commited to the server, they will still appear if you delete them and don’t apply a filter

Now, the user interface just have to bind to the items from the localDataSource, not the remote one:

<script type="text/javascript">
    $(function () {

        // Creates a ViewModel instance
        viewModel = new ViewModel();

<div data-bind="foreach: items">
	<!-- Do something to show the items -->