Question

I’m fairly new to knockout.js, however, I’ve been happily using it in my ASP.NET MVC 4 project, until I ran into this obstacle which has been bothering me for a while, can’t seem to put my finger on it.

The scenario which I’m working on requires several combinations of location data (region, country, city), i.e. cascading dropdown lists, which isn’t a problem to do when inputting fresh data, but I ran into problem(s) when trying to edit the saved data.

Data is in JSON format, with nested arrays, looks like this (shortened for illustration purposes):

var newData = 
[
  {
    "ID":1,
    "Name":"Australia and New Zealand",
    "Countries":[
      {
        "ID":13,
        "Name":"Australia",
        "Cities":[
          {
            "ID":19,
            "Name":"Brisbane"
          },
          {
            "ID":28,
            "Name":"Cairns"
          },
...

I suspect I can’t load the data (or more clearly, to bind it) properly since I’m having trouble accessing the Region sub-array (which contains Region’s Countries) and the Countries sub-array (which contains Countries’ Cities).

Then there’s the matter of having prepopulated options, which works partially, the viewmodel loads the number of lines, but doesn’t select anything.

Here’s the VM:

   var existingRows = [
    {
        "Region": 1,
        "Country": 13,
        "City": 19
    },
    {
        "Region": 1,
        "Country": 158,
        "City": 3
    }];

   var Location = function (region, country, city) {
       var self = this;
       self.region = ko.observable(region);
       self.country = ko.observable(country);
       self.city = ko.observable(city);

       // Whenever the region changes, reset the country selection
       self.region.subscribe(function () {
           self.country(undefined);
       });

       // Whenever the country changes, reset the city selection
       self.country.subscribe(function () {
           self.city(undefined);
       });
   };

   var LocationViewModel = function (data) {
       var self = this;

       self.lines = ko.observableArray(ko.utils.arrayMap(data, function (row)
       {
           var rowRegion = ko.utils.arrayFirst(newData, function (region)
           {
               return region.ID == row.Region;
           });
           var rowCountry = ko.utils.arrayFirst(rowRegion.Countries, function (country) {
               return country.ID == row.Country;
           });
           var rowCity = ko.utils.arrayFirst(rowCountry.Cities, function (city) {
           return city.ID == row.City;
           });
           return new Location(rowRegion, rowCountry, rowCity);
       }));

       // Operations
       self.addLine = function () {
           self.lines.push(new Location())
       };
       self.removeLine = function (line) {
           self.lines.remove(line)
       };
   };

   var lvm = new LocationViewModel(existingRows);

   $(function () {
       ko.applyBindings(lvm);
   });

HTML code:

<tbody data-bind="foreach: lines">
    <tr>
        <td><select data-bind="options: newData, optionsText: 'Name', optionsValue: 'ID', optionsCaption: 'Select a region...', attr: { name: 'SubRegionIndex' + '['+$index()+']' }, value: region"></select></td>
        <td><select data-bind="options: Countries, optionsText: 'Name', optionsValue: 'ID', optionsCaption: 'Select a country...', attr: { name: 'CountryIndex' + '['+$index()+']' }, value: country"></select></td>
        <td><select data-bind="options: Cities, optionsText: 'Name', optionsValue: 'ID', optionsCaption: 'Select a city...', attr: { name: 'CityIndex' + '['+$index()+']' }, value: city"></select></td>
        <td><a href='#' data-bind='click: $parent.removeLine'>Remove</a></td>
    </tr>    
</tbody>

I tried to modify the Cart editor example from the knockout.js website with prepopulated data, but haven’t really made much progress, I seem to be missing something. Didn’t really find anything with nested arrays so I’m stuck here…

I’ve put up the full code on JSFiddle here:
http://jsfiddle.net/fgXA2/1/

Any help would be appreciated.

Answer 1

The problem is the way in which you are binding to the selected item in your select lists:

<select data-bind="
    options: newData, 
    optionsText: 'Name', 
    optionsValue: 'ID', 
    value: region">
</select>

Here you are binding the ID property from your JSON data to the region property on your view model.

This means that when you bind your second select list:

<td data-bind="with: region">
    <select data-bind="
        options: Countries, 
        optionsText: 'Name', 
        optionsValue: 'ID', 
        value: $parent.country">
    </select>
</td>

You attempt to bind to region.Countries. However, region simply contains the selected region ID. In this case the console is your friend:

Uncaught Error: Unable to parse bindings. Message: ReferenceError:
Countries is not defined;

The same problem is true of your third select list for Cities since you are now attempting to bind to country.Cities where country is also just the ID.

There are two options available here. The first is to remove the optionsValue parameters, thus binding the actual JSON objects to your view model properties. That and a binding error on your Cities select box (you were binding to CityName instead of Name) were the only problems:

http://jsfiddle.net/benfosterdev/wHtRZ/

As you can see from the example I’ve used the ko.toJSON utility to output your view model’s object graph. This can be very useful in resolving problems (in your case you would have seen that the region property was just an number).

The downside of the above approach is that you end up storing a copy of all of the countries, and their cities for the selected country in your view model.

A better solution if dealing with large data sets would be to only store the selected identifier (which I believe you were attempting to do originally) and then define computed properties that filter your single data set for the required values.

An example of this can be seen at http://jsfiddle.net/benfosterdev/Bbbt3, using the following computed properties:

    var getById = function (items, id) {
        return ko.utils.arrayFirst(items, function (item) {
            return item.ID === id;
        });
    };

    this.countries = ko.computed(function () {
        var region = getById(this.selectedRegion.regions, this.selectedRegion());
        return region ? ko.utils.arrayMap(region.Countries, function (item) {
            return {
                ID: item.ID,
                Name: item.Name
            };
        }) : [];
    }, this);

    this.cities = ko.computed(function () {
        var region = getById(this.selectedRegion.regions, this.selectedRegion());
        if (region) {
            var country = getById(region.Countries, this.selectedCountry());
            if (country) {
                return country.Cities;
            }
        }

    }, this);

You can see from the rendered object graph that only the currently selected countries and cities are copied to the view model.