Merge lp:~martin-borho/ubuntu-weather-app/weather-data-api into lp:ubuntu-weather-app/obsolete.trunk

[Martin Borho]

Added first version of Weather-Data-Api and Storage

Added first version of Weather-Data-Api and Storage (for now based on QtQuick.LocalStorage 2.0)

The WeatherApi can be expanded with other services (see OpenWeatherMapApi object in WeatherApi.js). The response object has 4 properties: obj.location (Location data), obj.current (CurrentCondition), obj.forecast (3-hours-based forecast) and obj.daily (DailyForecast).

The whole API data-response is meant to be saved "as is" in the storage, together with a timestamp.

Missing:
- better error-handling
- proper date handling
- better response format
- ...

For a complete cycle of location searching, requesting data from openweathermap.org and storage related actions copy the following to your weather.qml:

    function onApiError(err) {
        console.log("onApiError")
        console.log(err.msg+" / "+err.request.url)
    }

    function onSearchSuccess(locations) {
        console.log("search result");
        locations.results.forEach(function(v) {
            console.log(v.name+", "+v.country);
        })
    }

    function search() {
        // search
        Api.WeatherApi.searchLocationByName({name:"hamburg", units:"metric"},onSearchSuccess,onApiError);
        Api.WeatherApi.searchLocationByPoint({coords: {"lon":10,"lat":53.549999}, units:"metric"}, onSearchSuccess,onApiError);
    }

    function onLocationDataSuccess(resp) {
        storage.clearDB();
        storage.insertLocation(resp);
        storage.getLocations(function(locations){
            locations.forEach(function(loc) {
                console.log('DB-Entry: '+loc.db.id+" "+loc.db.updated);
                storage.updateLocation(loc.db.id, loc);
            });
            storage.getLocations(listLocations);
        });
    }

    function listLocations(locations) {
        locations.forEach(function(loc) {
            console.log('DB-Entry: '+loc.db.id+" "+loc.db.updated);
            console.log("Data for "+loc.location.name+" ["+loc.location.service+"/"+loc.location.service_id+"]");
            console.log("Current Condition:");
            if(loc.current.error === undefined) {
                console.log(loc.current.results.condition.main+" "+loc.current.results.condition.description)
            } else {
                console.log("ERROR: "+loc.current.msg+" / "+loc.current.request.url);
            }

            console.log("Forecast")
            if(loc.forecast.error === undefined) {
                loc.forecast.results.forEach(function(f) {
                    console.log(f.date+", "+f.temp);
                })
            } else {
                console.log("ERROR: "+loc.forecast.msg+" / "+loc.forecast.request.url);
            }

            console.log("Daily forecast")
            if(loc.daily.error === undefined) {
                loc.daily.results.forEach(function(f) {
                    console.log(f.timestamp+", "+f.temp);
                })
            } else {
                console.log("ERROR: "+loc.daily.msg+" / "+loc.daily.request.url);
            }
            console.log('delete location');
            storage.clearLocation(loc.db.id);

            storage.getLocations(function(res) {
                console.log(res.length+" entrys left in DB");
            });
        });
    }

    function requestLocationWeather() {
        // weather data requests
        var location = {service: "openweathermap", service_id: 2911298, name: "Hamburg"};
        Api.WeatherApi.getLocationData({location:location, units: "metric"}, onLocationDataSuccess, onApiError);
    }

    Component.onCompleted: {
        search();
        requestLocationWeather();
    }

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

PASSED: Continuous integration, rev:10
http://91.189.93.125:8080/job/ubuntu-weather-app-ci/2/
Executed test runs:
    SUCCESS: http://91.189.93.125:8080/job/ubuntu-weather-app-quantal-amd64-ci/2/console
    SUCCESS: http://91.189.93.125:8080/job/ubuntu-weather-app-raring-amd64-ci/2/console

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

review: Approve (continuous-integration)

[Michael Hall (mhall119)]

Looks good to me. We should consider using U1DB for storing locations, so we can sync across devices, but this if fine for now.

review: Approve

=== added file 'components/Storage.qml'
--- components/Storage.qml	1970-01-01 00:00:00 +0000
+++ components/Storage.qml	2013-03-28 15:37:25 +0000
@@ -0,0 +1,68 @@
+import QtQuick.LocalStorage 2.0
+import QtQuick 2.0
+
+Item {
+    property var db: null
+
+    function openDB() {
+        if(db !== null) return;
+
+        db = LocalStorage.openDatabaseSync("ubuntu-weather-app", "", "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');
+                });
+        }
+    }
+
+    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.transaction(
+            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["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');
+        });
+    }
+}
 
=== added file 'components/WeatherApi.js'
--- components/WeatherApi.js	1970-01-01 00:00:00 +0000
+++ components/WeatherApi.js	2013-03-28 15:37:25 +0000
@@ -0,0 +1,218 @@
+.pragma library
+
+var OpenWeatherMapApi = (function() {
+    /**
+      provides neccessary methods for requesting and preparing data from OpenWeatherMap.org
+    */
+    var _baseUrl = "http://api.openweathermap.org/data/2.1/";
+    //
+    function _buildSearchResult(request, data) {
+        var searchResult = {
+            results: [],
+            request: request
+        }
+        data.list.forEach(function(r) {
+           searchResult.results.push({
+                service: "openweathermap",
+                service_id: r.id,
+                name: r.name,
+                coord: r.coords,
+                country: (r.sys && r.sys.country) ? r.sys.country : null
+            });
+        })
+        return searchResult;
+    }
+    //
+    function _buildDataPoint(data) {
+        // TODO add snow or rain data
+        var result = {
+            timestamp: data.dt,
+            date: (data.date !== undefined) ? data.date : ((data.dt_txt !== undefined) ? data.dt_txt: null),
+            temp: data.main.temp,
+            temp_min: data.main.temp_min,
+            temp_max: data.main.temp_max,
+            humidity: data.main.humidity,
+            pressure: data.main.pressure,
+            wind_speed: data.wind.speed,
+            wind_deg: data.wind.deg,
+            condition: data.weather[0]
+        };
+        if(data.id !== undefined) {
+            result["service"] = "openweathermap";
+            result["service_id"] =  data.id;
+
+        }
+        return result;
+    }
+    //
+    function _buildCurrentCondition(request, data) {
+        var currentResult = {
+            results: _buildDataPoint(data),
+            request: request
+        }
+        return currentResult;
+    }
+    //
+    function _buildForecast(request, data) {
+        var forecastResult = {
+            results: [],
+            request: request
+        }
+        data.list.forEach(function(f) {
+            forecastResult.results.push(_buildDataPoint(f));
+        });
+        return forecastResult;
+    }
+    //
+    function _buildDailyForecast(request, data) {
+        var forecastResult = {
+            results: [],
+            request: request
+        }
+        data.list.forEach(function(f) {
+            // TODO date_txt
+            forecastResult.results.push({
+                timestamp: f.dt,
+                temp: f.temp,
+                night: f.night,
+                eve: f.eve,
+                morn: f.morn,
+                pressure: f.pressure,
+                humidity: f.humidity,
+                condition: f.weather,
+                wind_speed: f.speed,
+                wind_deg: f.deg
+            });
+        });
+        return forecastResult;
+    }
+    //
+    return {
+        //
+        getSearchByNameRequest: function(params) {
+            var request = {
+                type: "search",
+                url: _baseUrl+"find/name?q="+encodeURIComponent(params.name)+"&units="+params.units,
+                formatter: _buildSearchResult
+            }
+            return request;
+        },
+        //
+        getSearchByPointRequest: function(params) {
+            var url = _baseUrl+"find/city?lat="+encodeURIComponent(params.coords.lat)
+                    +"&lon="+encodeURIComponent(params.coords.lon)+"&units="+params.units,
+                request = {
+                    type: "search",
+                    url: url,
+                    formatter: _buildSearchResult
+                };
+            return request;
+        },
+        //
+        getCurrentConditionRequest: function(params) {
+            var request = {
+                type: "current",
+                url: _baseUrl + "weather/city/"+params.location.service_id+"?units="+params.units,
+                formatter: _buildCurrentCondition
+            }
+            return request;
+        },
+        //
+        getForecastRequest: function(params) {
+            var request = {
+                type: "forecast",
+                url: _baseUrl + "forecast/city/"+params.location.service_id+"?units="+params.units,
+                formatter: _buildForecast
+            }
+            return request;
+        },
+        //
+        getDailyForecastRequest: function(params) {
+            var request = {
+                type: "daily",
+                url: _baseUrl + "forecast/city/"+params.location.service_id+"?mode=daily_compact&units="+params.units,
+                formatter: _buildDailyForecast
+            }
+            return request;
+        }
+    }
+
+})();
+
+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["openweathermap"];
+    }
+    //
+    function _sendRequest(request, onSuccess, onError) {
+        var xmlHttp = new XMLHttpRequest();
+        if (xmlHttp) {
+            console.log(request.url);
+            xmlHttp.open('GET', request.url, true);
+            xmlHttp.onreadystatechange = function () {
+                if (xmlHttp.readyState == 4) {
+                    var json = JSON.parse(xmlHttp.responseText);
+                    if(xmlHttp.status === 200) {
+                        var result = request.formatter(request,json);
+                        onSuccess(result);
+                    } else {
+                        onError({error: true, msg: "something went wrong", request: request});
+                    }
+                }
+            };
+            xmlHttp.send(null);
+        }
+    }
+    //
+    return  {
+        getForecast: function(params, onSuccess, onError) {
+            var request = _getService().getForecastRequest(params);
+            _sendRequest(request, onSuccess, onError);
+        },
+        //
+        getDailyForecast: function(params, onSuccess, onError) {
+            var request = _getService().getDailyForecastRequest(params);
+            _sendRequest(request, onSuccess, onError);
+        },
+        //
+        getCurrentCondition: function(params, onSuccess, onError) {
+            var request = _getService().getCurrentConditionRequest(params);
+            _sendRequest(request, onSuccess, onError);
+        },
+        //
+        searchLocationByName: function(params, onSuccess, onError) {
+            var request = _getService().getSearchByNameRequest(params);
+            _sendRequest(request, onSuccess, onError);
+        },
+        //
+        searchLocationByPoint: function(params, onSuccess, onError) {
+            var request = _getService().getSearchByPointRequest(params);
+            _sendRequest(request, onSuccess, onError);
+        },
+        //
+        getLocationData: function(params, onSuccess, onError) {
+            var response = {
+                location: params.location
+            },
+            addDataToResponse = (function(data) {
+                response[data.request.type] = data;
+                if(response["current"] !== undefined && response["forecast"] !== undefined && response["daily"] !== undefined) {
+                    onSuccess(response);
+                }
+            })
+
+            this.getCurrentCondition(params, addDataToResponse, addDataToResponse)
+            this.getForecast(params, addDataToResponse, addDataToResponse);
+            this.getDailyForecast(params, addDataToResponse, addDataToResponse);
+        }
+    }
+})({
+    "openweathermap": OpenWeatherMapApi
+});
 
=== modified file 'weather.qml'
--- weather.qml	2013-03-14 21:46:34 +0000
+++ weather.qml	2013-03-28 15:37:25 +0000
@@ -1,6 +1,7 @@
 import QtQuick 2.0
 import Ubuntu.Components 0.1
 import "components" as Components
+import "components/WeatherApi.js" as Api
 
 /*!
     \brief MainView with Tabs element.
@@ -15,6 +16,10 @@
     width: units.gu(50)
     height: units.gu(75)
     
+    Components.Storage{
+        id: storage
+    }
+
     Tabs {
         id: tabs
         anchors.fill: parent