Merge lp:~martin-borho/ubuntu-weather-app/reboot-data into lp:ubuntu-weather-app

[Martin Borho]

Added WeatherApi.js data provider client. Also added old Storage.qml to reuse data from the old weather app until storage is reimplemented.

Added WeatherApi.js for data provider access. Added also old Storage.qml with LocalStorage for using locations (and settings?) from the old weather app, until storage with u1db is reimplemented!

When the app is started, locations found in LocalStorage will get updated. Except they are not older than 30mins, than the data-client will return the data which was given in for the location (cached!).

Example calls from QML:

    function responseDataHandler(messageObject) {
        if(!messageObject.error) {
            if(messageObject.action === "updateData") {
                messageObject.result.forEach(function(loc) {
                    // replace location data in cache with refreshed values
                    if(loc["save"] === true) {
                        //storage.updateLocation(loc.db.id, loc);
                    }
                });
                print("\n\n##### location data result ####")
                print(JSON.stringify(messageObject.result));
            }
        } else {
            // handle errors
            console.log(messageObject.error.msg+" / "+messageObject.error.request.url)
        }
    }

    function demoLoadLoactionWeather() {
        var payload = {
            "action": "updateData", // action called
            "params": {
                "api_key": Key.twcKey,
                "force": true, // true/false - force api call, independant of caching state
                "locations": [ // list of locations
                    {
                        "location": { // location data as from search service
                            "objectName": "",
                            "adminName1": "Hamburg",
                            "adminName2": "",
                            "adminName3": "",
                            "areaLabel": "Hamburg, Germany",
                            "coord": {
                                "lat": "53.57532",
                                "lon": "10.01534"
                            },
                            "country": "DE",
                            "countryName": "Germany",
                            "name": "Hamburg",
                            "population": 1739117,
                            "services": {
                                "geonames": 2911298
                            },
                            "timezone": {
                                "dstOffset": 2,
                                "gmtOffset": 1,
                                "timeZoneId": "Europe/Berlin"
                            }
                        },
                        "updated": 1422196837780, // used for cache check, will reload if older than 30mins
                        "db": { // storage related data
                            "id": 4,
                            "updated": "2015-01-25T14:40:37.780Z"
                        }
                    }
                ],
                "service": "weatherchannel" // service to call
            }
        }
        // request weather data from the backend with callback to call with the results,
        // cache handling in backend!
        WeatherApi.sendRequest(payload, responseDataHandler)
    }

    function demoGeoLookup() {
        WeatherApi.sendRequest({"action":"getGeoIp","params":{}}, function(result) {
            print("\n\n#### location search by geoip ####")
            print(JSON.stringify(result))
        })

        var byPointPayload = {"action":"searchByPoint", "params": {"coords": {"lat":"53.5828","lon":"9.9808"}}}
        WeatherApi.sendRequest(byPointPayload, function(result) {
            print("\n\n#### location search by lat/long ####")
            print(JSON.stringify(result))
        })

        var byNamePayload = {"action":"searchByName","params":{"name":"London","units":"metric"}}
        WeatherApi.sendRequest(byNamePayload, function(result) {
            print("\n\n##### location search by name ####")
            print(JSON.stringify(result.result))
        })
    }

    Component.onCompleted: {
        demoGeoLookup()
        demoLoadLoactionWeather()

    }

[Victor Thompson (vthompson)]

Please change "keys.js" to "key.js", or rename the file to match the CMakeLists.txt file

Install the project...
-- Install configuration: ""
-- Installing: /tmp/tmp.o7PpsVrGpn//manifest.json
-- Installing: /tmp/tmp.o7PpsVrGpn//ubuntu-weather-app.apparmor
-- Installing: /tmp/tmp.o7PpsVrGpn/share/applications/ubuntu-weather-app.desktop
CMake Error at cmake_install.cmake:72 (FILE):
  file INSTALL cannot find "/home/victor/Development/reboot-data/keys.js".

review: Needs Fixing

[lp:~martin-borho/ubuntu-weather-app/reboot-data]

6. By Martin Borho on 2015-01-28

fixed typo

[Victor Thompson (vthompson)]

It might also be a good idea to rename the "KEYS_FILE" variable to be "KEY_FILE", assuming it won't need to hold multiple API keys.

review: Needs Information

[lp:~martin-borho/ubuntu-weather-app/reboot-data]

7. By Martin Borho on 2015-01-29

renamed KEYS_FILE to KEY_FILE

[Victor Thompson (vthompson)]

LGTM!

review: Approve

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:7
http://91.189.93.70:8080/job/ubuntu-weather-app-reboot-ci/2/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/ubuntu-weather-app-reboot-vivid-amd64-ci/2/console

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-weather-app-reboot-ci/2/rebuild

review: Needs Fixing (continuous-integration)

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

review: Approve (continuous-integration)

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-01-23 23:15:52 +0000
+++ CMakeLists.txt	2015-01-29 08:55:03 +0000
@@ -35,6 +35,7 @@
 set(DESKTOP_FILE "${APP_HARDCODE}.desktop")
 set(ICON [e-mail])
 set(AUTOPILOT_DIR ubuntu_weather_app)
+set(KEY_FILE key.js)
 
 # Set install paths
 if(CLICK_MODE)
@@ -99,6 +100,8 @@
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${DESKTOP_FILE}
         DESTINATION ${CMAKE_INSTALL_DATADIR}/applications)
 
+install(FILES ${KEY_FILE} DESTINATION ${CMAKE_INSTALL_PREFIX})
+
 add_subdirectory(app)
 add_subdirectory(backend)
 add_subdirectory(po)

=== modified file 'app/CMakeLists.txt'
--- app/CMakeLists.txt	2015-01-23 23:15:52 +0000
+++ app/CMakeLists.txt	2015-01-29 08:55:03 +0000
@@ -12,4 +12,5 @@
 install(FILES ${MAIN_QML} DESTINATION ${UBUNTU-WEATHER_APP_DIR})
 
 add_subdirectory(components)
+add_subdirectory(data)
 

=== added directory 'app/data'
=== added file 'app/data/CMakeLists.txt'
--- app/data/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ app/data/CMakeLists.txt	2015-01-29 08:55:03 +0000
@@ -0,0 +1,5 @@
+file(GLOB DATA_QML_JS_FILES *.qml *.js)
+
+add_custom_target(ubuntu-weather-app_data_QMlFiles ALL SOURCES ${DATA_QML_JS_FILES})
+
+install(FILES ${DATA_QML_JS_FILES} DESTINATION ${UBUNTU-WEATHER_APP_DIR}/data)

=== added file 'app/data/Storage.qml'
--- app/data/Storage.qml	1970-01-01 00:00:00 +0000
+++ app/data/Storage.qml	2015-01-29 08:55:03 +0000
@@ -0,0 +1,136 @@
+/*
+ * Copyright (C) 2013, 2014, 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Martin Borho <[e-mail]>
+ */
+import QtQuick.LocalStorage 2.0
+import QtQuick 2.3
+
+Item {
+    property var db: null
+
+    function openDB() {
+        if(db !== null) return;
+
+        db = LocalStorage.openDatabaseSync("com.ubuntu.weather", "", "Default Ubuntu weather app", 100000);
+
+        if (db.version === "") {
+            db.changeVersion("", "0.1",
+                function(tx) {
+                    tx.executeSql('CREATE TABLE IF NOT EXISTS Locations(id INTEGER PRIMARY KEY AUTOINCREMENT, data TEXT, date TEXT)');
+                    console.log('Database created');
+                });
+            // reopen database with new version number
+            db = LocalStorage.openDatabaseSync("com.ubuntu.weather", "", "Default Ubuntu weather app", 100000);
+        }
+
+        if(db.version === "0.1") {
+            db.changeVersion("0.1", "0.2",
+                function(tx) {
+                    tx.executeSql('CREATE TABLE IF NOT EXISTS settings(key TEXT UNIQUE, value TEXT)');
+                    console.log('Settings table added, Database upgraded to v0.2');
+                });
+            // reopen database with new version number
+            db = LocalStorage.openDatabaseSync("com.ubuntu.weather", "", "Default Ubuntu weather app", 100000);
+        }
+
+        if(db.version === "0.2") {
+            db.changeVersion("0.2", "0.3",
+                function(tx) {
+                    tx.executeSql('DELETE FROM Locations WHERE 1');
+                    console.log('Removed old locations, Database upgraded to v0.3');
+                });
+        }
+    }
+
+    function saveSetting(key, value) {
+        openDB();
+        db.transaction( function(tx){
+            tx.executeSql('INSERT OR REPLACE INTO settings VALUES(?, ?)', [key, value]);
+        });
+    }
+
+    function getSettings(callback) {
+        openDB();
+        var settings = {};
+        db.readTransaction(
+            function(tx){
+                var rs = tx.executeSql('SELECT key, value FROM Settings');
+                for(var i = 0; i < rs.rows.length; i++) {
+                    var row = rs.rows.item(i);
+                    settings[row.key] = row.value;
+                }
+                callback(settings);
+            }
+        );
+    }
+
+    function clearSetting(name) {
+        openDB();
+        db.transaction(function(tx){
+            tx.executeSql('DELETE FROM Settings WHERE key = ?', [name]);
+        });
+    }
+
+    function insertLocation(data) {
+        openDB();
+        var res;
+        db.transaction( function(tx){
+            var r = tx.executeSql('INSERT INTO Locations(data, date) VALUES(?, ?)', [JSON.stringify(data), new Date().getTime()]);
+            res = r.insertId;
+        });
+        return res;
+    }
+
+    function updateLocation(dbId, data) {
+        openDB();
+        db.transaction( function(tx){
+            var r = tx.executeSql('UPDATE Locations SET data = ?, date=? WHERE id = ?', [JSON.stringify(data), new Date().getTime(), dbId])
+        });
+    }
+
+    function getLocations(callback) {
+        openDB();
+        db.readTransaction(
+            function(tx){
+                var locations = [];
+                var rs = tx.executeSql('SELECT * FROM Locations');
+                for(var i = 0; i < rs.rows.length; i++) {
+                    var row = rs.rows.item(i),
+                        locData = JSON.parse(row.data);
+                    locData["updated"] = parseInt(row.date, 10);
+                    locData["db"] = {id: row.id, updated: new Date(parseInt(row.date, 10))};
+                    locations.push(locData);
+                }
+                callback(locations);
+            }
+        );
+    }
+
+    function clearLocation(location_id) {
+        openDB();
+        db.transaction(function(tx){
+            tx.executeSql('DELETE FROM Locations WHERE id = ?', [location_id]);
+        });
+    }
+
+    function clearDB() { // for dev purposes
+        openDB();
+        db.transaction(function(tx){
+            tx.executeSql('DELETE FROM Locations WHERE 1');
+            tx.executeSql('DELETE FROM Settings WHERE 1');
+        });
+    }
+}

=== added file 'app/data/WeatherApi.js'
--- app/data/WeatherApi.js	1970-01-01 00:00:00 +0000
+++ app/data/WeatherApi.js	2015-01-29 08:55:03 +0000
@@ -0,0 +1,743 @@
+.pragma library
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Raúl Yeguas <[e-mail]>
+ *              Martin Borho <[e-mail]>
+ *              Andrew Starr-Bochicchio <[e-mail]>
+ */
+
+/**
+*  Version of the response data format.
+*  Increase this number to force a refresh.
+*/
+var RESPONSE_DATA_VERSION = 20140315;
+
+/**
+* Helper functions
+*/
+function debug(obj) {
+    print(JSON.stringify(obj))
+}
+//
+function calcFahrenheit(celsius) {
+        return celsius * 1.8 + 32;
+}
+//
+function calcMph(ms) {
+    return ms*2.24;
+}
+//
+function calcInch(mm) {
+    return mm/25.4;
+}
+//
+function calcKmh(ms) {
+    return ms*3.6;
+}
+//
+function convertKmhToMph(kmh) {
+    return kmh*0.621;
+}
+//
+function calcWindDir(degrees) {
+    var direction =  "?";
+    if(degrees >=0 && degrees <= 30){
+        direction = "N";
+    } else if(degrees >30 && degrees <= 60){
+        direction = "NE";
+    } else if(degrees >60 && degrees <= 120){
+        direction = "E";
+    } else if(degrees >120 && degrees <= 150){
+        direction = "SE";
+    } else if(degrees >150 && degrees <= 210){
+        direction = "S";
+    } else if(degrees >210 && degrees <= 240){
+        direction = "SW";
+    } else if(degrees >240 && degrees <= 300){
+        direction = "W";
+    } else if(degrees >300 && degrees <= 330){
+        direction = "NW";
+    } else if(degrees >330 && degrees <= 360){
+        direction = "N";
+    }
+    return direction;
+}
+
+//
+function getLocationTime(tstamp) {
+    var locTime = new Date(tstamp);
+    return {
+        year: locTime.getUTCFullYear(),
+        month: locTime.getUTCMonth(),
+        date: locTime.getUTCDate(),
+        hours: locTime.getUTCHours(),
+        minutes: locTime.getUTCMinutes()
+    }
+}
+// Serialize a JavaScript object to URL parameters
+// E.g. {param1: value1, param2: value2} to "param1=value&param2=value"
+// TODO: it'd be nice to make it work with either passing a single object
+// or several at once
+function parameterize(obj) {
+  var str = [];
+  for(var param in obj) {
+     str.push(encodeURIComponent(param) + "=" + encodeURIComponent(obj[param]));
+  }
+  return str.join("&");
+}
+
+var GeoipApi = (function() {
+    var _baseUrl = "http://geoip.ubuntu.com/lookup";
+    return {
+        getLatLong: function(params, apiCaller, onSuccess, onError) {
+            var request = { type: "geolookup",url: _baseUrl},
+                resultHandler = (function(request, xmlDoc) {
+                    var coords = {},
+                        childNodes = xmlDoc.childNodes;
+                    for(var i=0;i<childNodes.length;i++) {
+                        if(childNodes[i].nodeName === "Latitude") {
+                            coords.lat = childNodes[i].firstChild.nodeValue;
+                        } else if(childNodes[i].nodeName === "Longitude") {
+                            coords.lon = childNodes[i].firstChild.nodeValue;
+                        }
+                    }
+                    onSuccess(coords);
+                }),
+                retryHandler = (function(err) {
+                    console.log("geolookup retry of "+err.request.url);
+                    apiCaller(request, resultHandler, onError);
+                });
+            apiCaller(request, resultHandler, retryHandler);
+        }
+    }
+})();
+
+var GeonamesApi = (function() {
+    /**
+      provides neccessary methods for requesting and preparing data from Geonames.org
+    */
+    var _baseUrl = "http://api.geonames.org/";
+    var _username = "uweatherdev"
+    var _addParams = "&maxRows=25&featureClass=P"
+    //
+    function _buildSearchResult(request, data) {
+        var searchResult = { locations: [], request: request };
+        if(data.geonames) {
+            data.geonames.forEach(function(r) {
+               searchResult.locations.push({
+                    name: r.name,
+                    coord: {lat: r.lat, lon: r.lng},
+                    country: r.countryCode,
+                    countryName: r.countryName,
+                    timezone: r.timezone,
+                    adminName1: r.adminName1,
+                    adminName2: r.adminName2,
+                    adminName3: r.adminName3,
+                    population: r.population,
+                    services: {
+                        "geonames": r.geonameId
+                    }
+                });
+            })
+        }
+        return searchResult;
+    }
+    //
+    return {
+        //
+        search: function(mode, params, apiCaller, onSuccess, onError) {
+            var request,
+                retryHandler = (function(err) {
+                        console.log("search retry of "+err.request.url);
+                        apiCaller(request, searchResponseHandler, onError);
+                }),
+                searchResponseHandler = function(request, data) {
+                    onSuccess(_buildSearchResult(request, data));
+                };
+            if(mode === "point") {
+                request = { type: "search",
+                            url: _baseUrl+ "findNearbyPlaceNameJSON?style=full&username="+encodeURIComponent(_username)
+                            +"&lat="+encodeURIComponent(params.coords.lat)+"&lng="+encodeURIComponent(params.coords.lon)
+                            +_addParams}
+            } else {
+                request = { type: "search",
+                            url: _baseUrl+ "searchJSON?style=full&username="+encodeURIComponent(_username)
+                                    +"&name_startsWith="+encodeURIComponent(params.name)+_addParams}
+            }
+            apiCaller(request, searchResponseHandler, retryHandler);
+        }
+    }
+
+})();
+
+var OpenWeatherMapApi = (function() {
+    /**
+      provides neccessary methods for requesting and preparing data from OpenWeatherMap.org
+    */
+    var _baseUrl = "http://api.openweathermap.org/data/2.5/";
+    //
+    var _serviceName = "openweathermap";
+    //
+    var _icon_map = {
+        "01d": "sun",
+        "01n": "moon",
+        "02d": "cloud_sun",
+        "02n": "cloud_moon",
+        "03d": "cloud_sun",
+        "03n": "cloud_moon",
+        "04d": "cloud",
+        "04n": "cloud",
+        "09d": "rain",
+        "09n": "rain",
+        "10d": "rain",
+        "10n": "rain",
+        "11d": "thunder",
+        "11n": "thunder",
+        "13d": "snow_shower",
+        "13n": "snow_shower",
+        "50d": "fog",
+        "50n": "fog"
+    }    
+    //
+    function _buildDataPoint(date, data) {
+        var result = {
+            timestamp: data.dt,
+            date: date,
+            metric: {
+                temp:data.main.temp,
+                windSpeed: calcKmh(data.wind.speed),
+                rain: data.main.rain || ((data.rain) ? data.rain["3h"] : false ) || 0,
+                snow: data.main.snow || ((data.snow) ? data.snow["3h"] : false ) || 0
+            },
+            imperial: {
+                temp: calcFahrenheit(data.main.temp),
+                windSpeed: calcMph(data.wind.speed),
+                rain: calcInch(data.main.rain || ((data.rain) ? data.rain["3h"] : false ) || 0),
+                snow: calcInch(data.main.snow || ((data.snow) ? data.snow["3h"] : false ) ||0)
+            },
+            humidity: data.main.humidity,
+            pressure: data.main.pressure,
+            windDeg: data.wind.deg,
+            windDir: calcWindDir(data.wind.deg),
+            icon: _icon_map[data.weather[0].icon],
+            condition: data.weather[0]
+        };
+        if(data.id !== undefined) {
+            result["service"] = _serviceName;
+            result["service_id"] =  data.id;
+        }
+        return result;
+    }
+    //
+    function _buildDayFormat(date, data) {
+        var result = {
+            date: date,
+            timestamp: data.dt,
+            metric: {
+                tempMin: data.temp.min,
+                tempMax: data.temp.max,
+                windSpeed: calcKmh(data.speed),
+                rain: data.rain || 0,
+                snow: data.snow || 0
+            },
+            imperial: {
+                tempMin: calcFahrenheit(data.temp.min),
+                tempMax: calcFahrenheit(data.temp.max),
+                windSpeed: calcMph(data.speed),
+                rain: calcInch(data.rain || 0),
+                snow: calcInch(data.snow || 0)
+            },
+            pressure: data.pressure,
+            humidity: data.humidity,
+            icon: _icon_map[data.weather[0].icon],
+            condition: data.weather[0],
+            windDeg: data.deg,
+            windDir: calcWindDir(data.deg),
+            hourly: []
+        }
+        return result;
+    }
+    //
+    function formatResult(data, location) {
+        var tmpResult = {},
+            result = [],
+            day=null,
+            offset=(location.timezone && location.timezone.gmtOffset) ? location.timezone.gmtOffset*60*60*1000: 0,
+            localNow = getLocationTime(new Date().getTime()+offset),
+            todayDate;        
+        print("["+location.name+"] "+JSON.stringify(localNow))
+        // add openweathermap id for faster responses
+        if(location.services && !location.services[_serviceName] && data["current"].id) {
+            location.services[_serviceName] = data["current"].id
+        }
+        //
+        data["daily"]["list"].forEach(function(dayData) {
+            var date = getLocationTime(((dayData.dt*1000)-1000)+offset), // minus 1 sec to handle +/-12 TZ
+                day = date.year+"-"+date.month+"-"+date.date;
+            if(!todayDate) {
+                if(localNow.year+"-"+localNow.month+"-"+localNow.date > day) {
+                    // skip "yesterday"
+                    return;
+                }
+                todayDate = date;
+            }
+            tmpResult[day] = _buildDayFormat(date, dayData);
+        })
+        //
+        var today = todayDate.year+"-"+todayDate.month+"-"+todayDate.date
+        tmpResult[today]["current"] = _buildDataPoint(todayDate, data["current"]);
+        if(data["forecast"] !== undefined) {
+            data["forecast"]["list"].forEach(function(hourData) {                
+                var dateData = getLocationTime((hourData.dt*1000)+offset),
+                    day = dateData.year+"-"+dateData.month+"-"+dateData.date;
+                if(tmpResult[day]) {
+                    tmpResult[day]["hourly"].push(_buildDataPoint(dateData, hourData));
+                }
+            })
+        }
+        //
+        for(var d in tmpResult) {
+            result.push(tmpResult[d]);
+        }
+        return result;
+    }
+    //
+    function _getUrls(params) {
+        var urls = {
+                current: "",
+                daily: "",
+                forecast: ""
+            },
+            latLongParams = "&lat="+encodeURIComponent(params.location.coord.lat)
+                + "&lon="+encodeURIComponent(params.location.coord.lon);
+        if(params.location.services && params.location.services[_serviceName]) {
+            urls.current = _baseUrl + "weather?units="+params.units+"&id="+params.location.services[_serviceName];
+            urls.daily = _baseUrl + "forecast/daily?id="+params.location.services[_serviceName]+"&cnt=10&units="+params.units
+            urls.forecast = _baseUrl + "forecast?id="+params.location.services[_serviceName]+"&units="+params.units
+
+        } else if (params.location.coord) {
+            urls.current = _baseUrl + "weather?units="+params.units+latLongParams;
+            urls.daily = _baseUrl+"forecast/daily?cnt=10&units="+params.units+latLongParams;
+            urls.forecast = _baseUrl+"forecast?units="+params.units+latLongParams;
+        }
+        return urls;
+    }
+    //
+    return {     
+        //
+        getData: function(params, apiCaller, onSuccess, onError) {
+            var urls = _getUrls(params),
+                handlerMap = {
+                current: { type: "current",url: urls.current},
+                daily: { type: "daily",url: urls.daily},
+                forecast: { type: "forecast", url: urls.forecast}},
+            response = {
+                location: params.location,
+                db: (params.db) ? params.db : null,
+                format: RESPONSE_DATA_VERSION
+            },
+            respData = {},
+            addDataToResponse = (function(request, data) {
+                var formattedResult;
+                respData[request.type] = data;
+                if(respData["current"] !== undefined
+                        && respData["forecast"] !== undefined
+                            && respData["daily"] !== undefined) {
+                    response["data"] = formatResult(respData, params.location)
+                    onSuccess(response);
+                }
+            }),
+            onErrorHandler = (function(err) {
+                onError(err);
+            }),
+            retryHandler = (function(err) {
+                console.log("retry of "+err.request.url);
+                var retryFunc = handlerMap[err.request.type];
+                apiCaller(retryFunc, addDataToResponse, onErrorHandler);
+            });
+            //
+            apiCaller(handlerMap.current, addDataToResponse, retryHandler);
+            apiCaller(handlerMap.forecast, addDataToResponse, retryHandler);
+            apiCaller(handlerMap.daily, addDataToResponse, retryHandler);
+        }
+    }
+
+})();
+
+var WeatherChannelApi = (function() {
+    /**
+      provides neccessary methods for requesting and preparing data from OpenWeatherMap.org
+    */
+    var _baseUrl = "http://wxdata.weather.com/wxdata/";
+    //
+    var _serviceName = "weatherchannel";
+    //
+    // see http://s.imwx.com/v.20131006.223722/img/wxicon/72/([0-9]+).png
+    var _iconMap = {
+        "0": "thunder", // ??
+        "1": "thunder", // ??
+        "2": "thunder", // ??
+        "3": "thunder", // ??
+        "4": "thunder", //T-Storms
+        "5": "snow_rain", //Rain / Snow
+        "6": "snow_rain", // ??
+        "7": "snow_rain", //Wintry Mix
+        "8": "scattered", //Freezing Drizzle
+        "9": "scattered", //Drizzle
+        "10": "rain", // ??
+        "11": "rain", //Showers
+        "12": "rain", //Rain
+        "13": "snow_shower", // ??
+        "14": "snow_shower", //Snow shower/Light snow
+        "15": "snow_shower", //
+        "16": "snow_shower", //Snow
+        "17": "thunder", // Hail??
+        "18": "snow_rain", // Rain / Snow ??
+        "19": "fog", //Fog ??
+        "20": "fog", //Fog
+        "21": "fog", //Haze
+        "22": "fog", // ??
+        "23": "fog", // Wind ??
+        "24": "overcast", //Partly Cloudy / Wind
+        "25": "overcast", // ??
+        "26": "overcast",//Cloudy
+        "27": "cloud_moon",//Mostly Cloudy
+        "28": "cloud_sun", //Mostly Cloudy
+        "29": "cloud_moon", //Partly Cloudy
+        "30": "cloud_sun", //Partly Cloudy
+        "31": "moon", //Clear
+        "32": "sun", //Sunny
+        "33": "cloud_moon", //Mostly Clear
+        "34": "cloud_sun", //Mostly Sunny
+        "35": "snow_rain", // ??
+        "36": "sun", //Sunny
+        "37": "thunder", //Isolated T-Storms
+        "38": "thunder", //Scattered T-Storms
+        "39": "scattered", //Scattered Showers
+        "40": "rain", // ??
+        "41": "snow", //Scattered Snow Showers
+        "42": "snow_shower", // ??
+        "43": "snow_shower", // ??
+        "44": "fog", // ??
+        "45": "scattered", // ??
+        "46": "snow_shower", //Snow Showers Early
+        "47": "thunder" //Isolated T-Storms
+    };
+    //
+    function _buildDataPoint(date, dataObj) {
+        var data = dataObj["Observation"] || dataObj,
+            result = {
+                timestamp: data.date || data.dateTime,
+                date: date,
+                metric: {
+                    temp: data.temp,
+                    tempFeels: data.feelsLike,
+                    windSpeed: data.wSpeed
+                },
+                imperial: {
+                    temp: calcFahrenheit(data.temp),
+                    tempFeels: calcFahrenheit(data.feelsLike),
+                    windSpeed: convertKmhToMph(data.wSpeed)
+                },
+                precipType: (data.precip_type !== undefined) ? data.precip_type : null,
+                propPrecip: (data.pop !== undefined) ? data.pop : null,
+                humidity: data.humid,
+                pressure: data.pressure,
+                windDeg: data.wDir,
+                windDir: data.wDirText,
+                icon: _iconMap[(data.wxIcon||data.icon)],
+                condition: data.text || data.wDesc,
+                uv: data.uv
+        };
+        if(_iconMap[data.wxIcon||data.icon] === undefined) {
+            print("ICON MISSING POINT: "+(data.wxIcon||data.icon)+" "+result.condition)
+        }
+        return result;
+    }
+    //
+    function _buildDayFormat(date, data, now) {
+        var partData = (now > data.validDate || data.day === undefined) ? data.night : data.day,
+            result = {
+            date: date,
+            timestamp: data.validDate,
+            metric: {
+                tempMin: data.minTemp,
+                tempMax: data.maxTemp,
+                windSpeed: partData.wSpeed
+            },
+            imperial: {
+                tempMin: calcFahrenheit(data.minTemp),
+                tempMax: calcFahrenheit(data.maxTemp || data.minTemp),
+                windSpeed: convertKmhToMph(partData.wSpeed)
+            },
+            precipType: partData.precip_type,
+            propPrecip: partData.pop,
+            pressure: null,
+            humidity: partData.humid,
+            icon: _iconMap[partData.icon],
+            condition: partData.phrase,
+            windDeg: partData.wDir,
+            windDir: partData.wDirText,
+            uv: partData.uv,
+            hourly: []
+        }
+        if(_iconMap[partData.icon] === undefined) {
+            print("ICON MISSING  DAY: "+partData.icon+" "+result.condition)
+        }
+        return result;
+    }
+    //
+    function formatResult(combinedData, location) {
+        var tmpResult = {}, result = [],
+            day=null, todayDate,
+            offset=(location.timezone && location.timezone.gmtOffset) ? location.timezone.gmtOffset*60*60*1000: 0,
+            now = new Date().getTime(),
+            nowMs = parseInt(now/1000),
+            localNow = getLocationTime(now+offset),
+            data = {
+                "location": combinedData[0]["Location"],
+                "daily": combinedData[0]["DailyForecasts"],
+                "forecast": combinedData[0]["HourlyForecasts"],
+                "current": combinedData[0]["StandardObservation"],
+            };
+        print("["+location.name+"] "+JSON.stringify(localNow));
+        // add openweathermap id for faster responses
+        if(location.services && !location.services[_serviceName] && data["location"].key) {
+            location.services[_serviceName] = data["location"].key
+        }                
+        // only 5 days of forecast for TWC
+        for(var x=0;x<5;x++) {
+            var dayData = data["daily"][x],
+                date = getLocationTime(((dayData.validDate*1000)-1000)+offset); // minus 1 sec to handle +/-12 TZ
+            day = date.year+"-"+date.month+"-"+date.date;
+            if(!todayDate) {
+                if(localNow.year+"-"+localNow.month+"-"+localNow.date > day) {
+                    // skip "yesterday"
+                    continue;
+                }
+                todayDate = date;
+            }
+            tmpResult[day] = _buildDayFormat(date, dayData, nowMs);
+        }
+        //
+        if(data["current"]) {
+            var today = todayDate.year+"-"+todayDate.month+"-"+todayDate.date
+            tmpResult[today]["current"] = _buildDataPoint(todayDate, data["current"]);
+        }
+        if(data["forecast"] !== undefined) {
+            data["forecast"].forEach(function(hourData) {
+                var dateData = getLocationTime((hourData.dateTime*1000)+offset),
+                    day = dateData.year+"-"+dateData.month+"-"+dateData.date;
+                if(tmpResult[day]) {                    
+                    tmpResult[day]["hourly"].push(_buildDataPoint(dateData, hourData));
+                }
+            })
+        }
+        //
+        for(var d in tmpResult) {
+            result.push(tmpResult[d]);
+        }
+        return result;
+    }
+    //
+    function _getUrl(params) {
+        var url, serviceId,
+            baseParams = {
+                key: params.api_key,
+                units: (params.units === "metric") ? "m" : "e",
+                locale: Qt.locale().name,
+                hours: "48",
+            },
+            commands = {
+                "mobileaggregation": "mobile/mobagg/",
+            };
+        if(params.location.services && params.location.services[_serviceName]) {
+            serviceId = encodeURIComponent(params.location.services[_serviceName]);
+            url = _baseUrl+commands["mobileaggregation"]+serviceId+".js?"+parameterize(baseParams);
+        } else if (params.location.coord) {
+            var coord = {lat: params.location.coord.lat, lng: params.location.coord.lon};
+            url = _baseUrl+commands["mobileaggregation"]+"get.js?"+parameterize(baseParams)+"&"+
+                  parameterize(coord);
+        }
+        return url;
+    }
+    //
+    return {
+        getData: function(params, apiCaller, onSuccess, onError) {
+            var url = _getUrl(params),
+                handlerMap = {
+                    all: { type: "all", url: url}
+                },
+                response = {
+                    location: params.location,
+                    db: (params.db) ? params.db : null,
+                    format: RESPONSE_DATA_VERSION
+                },
+                addDataToResponse = (function(request, data) {
+                    var formattedResult;
+                    response["data"] = formatResult(data, params.location);
+                    onSuccess(response);
+                }),
+                onErrorHandler = (function(err) {
+                    onError(err);
+                });
+            apiCaller(handlerMap.all, addDataToResponse, onErrorHandler);
+        }
+    }
+})();
+
+var WeatherApi = (function(_services) {
+    /**
+      proxy for requesting weather apis, the passed _services are providing the respective api endpoints
+      and formatters to build a uniform response object
+    */
+    function _getService(name) {
+        if(_services[name] !== undefined) {
+            return _services[name];
+        }
+        return _services["weatherchannel"];
+    }
+    //
+    function _sendRequest(request, onSuccess, onError) {
+        var xmlHttp = new XMLHttpRequest();
+        if (xmlHttp) {
+            console.log("Sent request URL: " + request.url);
+            xmlHttp.open('GET', request.url, true);
+            xmlHttp.onreadystatechange = function () {
+                try {
+                    if (xmlHttp.readyState == 4) {
+                        if(xmlHttp.status === 200) {
+                            if(xmlHttp.responseXML) {
+                                onSuccess(request, xmlHttp.responseXML.documentElement);
+                            } else {
+                                var json = JSON.parse(xmlHttp.responseText);
+                                onSuccess(request,json);
+                            }
+                        } else {
+                            onError({
+                                msg: "wrong response http code, got "+xmlHttp.status,
+                                request: request
+                            });
+                        }
+                    }
+                } catch (e) {
+                    print("Exception: "+e)
+                    onError({msg: "wrong response data format", request: request});
+                }
+            };
+            xmlHttp.send(null);
+        }
+    }
+    //
+    return  {
+        //
+        geoLookup: function(params, onSuccess, onError) {
+            var service = _getService('geoip'),
+                geoNameService = _getService('geonames'),
+                lookupHandler = function(data) {
+                    print("Geolookup: "+JSON.stringify(data))
+                    geoNameService.search("point", {coords:data}, _sendRequest, onSuccess, onError);
+                };
+            service.getLatLong(params, _sendRequest, lookupHandler, onError)
+        },
+        //
+        search: function(mode, params, onSuccess, onError) {
+            var service = _getService('geonames');
+            service.search(mode, params, _sendRequest, onSuccess, onError);
+        },
+        //
+        getLocationData: function(params, onSuccess, onError) {
+            var service = _getService(params.service);
+            service.getData(params, _sendRequest, onSuccess, onError);
+        },
+    }
+})({
+    "openweathermap": OpenWeatherMapApi,
+    "weatherchannel": WeatherChannelApi,
+    "geonames": GeonamesApi,
+    "geoip": GeoipApi
+});
+
+var sendRequest = function(message, responseCallback) {
+    // handles the response data
+    var finished = function(result) {
+        // print result to get data for test json files
+        // print(JSON.stringify(result));
+        //WorkerScript.sendMessage({
+        responseCallback({
+            action: message.action,
+            result: result
+        })
+    }
+    // handles errors
+    var onError = function(err) {
+        console.log(JSON.stringify(err, null, true));
+        //WorkerScript.sendMessage({ 'error': err})
+        responseCallback({ 'error': err})
+    }
+    // keep order of locations, sort results
+    var sortDataResults = function(locA, locB) {
+        return locA.db.id - locB.db.id;
+    }
+    // perform the api calls
+    if(message.action === "searchByName") {
+        WeatherApi.search("name", message.params, finished, onError);
+    } else if(message.action === "searchByPoint") {
+        WeatherApi.search("point", message.params, finished, onError);
+    } else if(message.action === "getGeoIp") {
+        WeatherApi.geoLookup(message.params, finished, onError);
+    } else if(message.action === "updateData") {
+        var locLength = message.params.locations.length,
+            locUpdated = 0,
+            result = [],
+            now = new Date().getTime();
+        if(locLength > 0) {
+            message.params.locations.forEach(function(loc) {
+                var updatedHnd = function (newData, cached) {
+                        locUpdated += 1;
+                        if(cached === true) {
+                            newData["save"] = false;
+                        } else {
+                            newData["save"] = true;
+                            newData["updated"] =  new Date().getTime();
+                        }
+                        result.push(newData);
+                        if(locUpdated === locLength) {
+                            result.sort(sortDataResults);
+                            finished(result);
+                        }
+                    },
+                    params = {
+                        location:loc.location,
+                        db: loc.db,
+                        units: 'metric',
+                        service: message.params.service,
+                        api_key: message.params.api_key
+                    },
+                    secsFromLastFetch = (now-loc.updated)/1000;
+                if( message.params.force===true || loc.format !== RESPONSE_DATA_VERSION || secsFromLastFetch > 1800){
+                    // data older than 30min, location is new or data format is deprecated
+                    WeatherApi.getLocationData(params, updatedHnd, onError);
+                } else {
+                    console.log("["+loc.location.name+"] returning cached data, time from last fetch: "+secsFromLastFetch)
+                    updatedHnd(loc, true);
+                }
+            })
+        } else {
+            finished(result);
+        }
+    }
+}

=== modified file 'app/ubuntu-weather-app.qml'
--- app/ubuntu-weather-app.qml	2015-01-24 00:41:10 +0000
+++ app/ubuntu-weather-app.qml	2015-01-29 08:55:03 +0000
@@ -18,6 +18,9 @@
 
 import QtQuick 2.3
 import Ubuntu.Components 1.1
+import "data" as Data
+import "data/WeatherApi.js" as WeatherApi
+import "../key.js" as Key
 
 MainView {
     id: weatherApp
@@ -36,6 +39,41 @@
     useDeprecatedToolbar: false
     anchorToKeyboard: true
 
+    Component.onCompleted: {
+        storage.getLocations(function(locations) {
+            WeatherApi.sendRequest({
+                action: "updateData",
+                params: {
+                    locations:locations,
+                    force:false,
+                    service: "weatherchannel",
+                    api_key: Key.twcKey
+                }
+            }, responseDataHandler)
+        })
+    }
+
+    function responseDataHandler(messageObject) {
+         if(!messageObject.error) {
+             if(messageObject.action === "updateData") {
+                 messageObject.result.forEach(function(loc) {
+                     // replace location data in cache with refreshed values
+                     if(loc["save"] === true) {
+                         storage.updateLocation(loc.db.id, loc);
+                     }
+                 });
+                 //print(JSON.stringify(messageObject.result));
+                 //buildTabs(messageObject.result);
+             }
+         } else {
+             console.log(messageObject.error.msg+" / "+messageObject.error.request.url)
+             // TODO error handling
+         }
+     }
+
+    Data.Storage {
+        id: storage
+    }
 
     Page {
         title: "Weather Reboot"

=== added file 'key.js'
--- key.js	1970-01-01 00:00:00 +0000
+++ key.js	2015-01-29 08:55:03 +0000
@@ -0,0 +1,1 @@
+var twcKey = "";