MMM-WunderGround.js

/* global Module */
/* Magic Mirror
 * Module: WunderGround
 *
 * By RedNax
 * MIT Licensed.
 */
Module.register("MMM-WunderGround", {

    // Default module config.
    defaults: {
        apikey: "",
        pws: "",
        units: config.units,
        updateInterval: 10 * 60 * 1000, // every 10 minutes
        animationSpeed: 1000,
        timeFormat: config.timeFormat,
        lang: config.language,
        showWindDirection: true,
        fade: true,
        fadePoint: 0.25, // Start on 1/4th of the list.
        tz: "",
        fcdaycount: "5",
        fcdaystart: "0",
        hourly: "0",
        hourlyinterval: "3",
        hourlycount: "2",
        fctext: "1",
        alerttime: 5000,
        roundTmpDecs: 1,
        UseCardinals: 0,
        layout: "vertical",




        initialLoadDelay: 2500, // 2.5 seconds delay. This delay is used to keep the OpenWeather API happy.
        retryDelay: 2500,

        apiBase: "http://api.wunderground.com/api/",

        iconTableDay: {
            "chanceflurries": "wi-day-snow-wind",
            "chancerain": "wi-day-showers",
            "chancesleet": "wi-day-sleet",
            "chancesnow": "wi-day-snow",
            "chancetstorms": "wi-day-storm-showers",
            "clear": "wi-day-sunny",
            "cloudy": "wi-cloud",
            "flurries": "wi-snow-wind",
            "fog": "wi-fog",
            "haze": "wi-day-haze",
            "hazy": "wi-day-haze",
            "mostlycloudy": "wi-cloudy",
            "mostlysunny": "wi-day-sunny-overcast",
            "partlycloudy": "wi-day-cloudy",
            "partlysunny": "wi-day-cloudy-high",
            "rain": "wi-rain",
            "sleet": "wi-sleet",
            "snow": "wi-snow",
            "tstorms": "wi-thunderstorm"
        },

        iconTableNight: {
            "chanceflurries": "wi-night-snow-wind",
            "chancerain": "wi-night-showers",
            "chancesleet": "wi-night-sleet",
            "chancesnow": "wi-night-alt-snow",
            "chancetstorms": "wi-night-alt-storm-showers",
            "clear": "wi-night-clear",
            "cloudy": "wi-night-alt-cloudy",
            "flurries": "wi-night-alt-snow-wind",
            "fog": "wi-night-fog",
            "haze": "wi-night-alt-cloudy-windy",
            "hazy": "wi-night-alt-cloudy-windy",
            "mostlycloudy": "wi-night-alt-cloudy",
            "mostlysunny": "wi-night-alt-partly-cloudy",
            "partlycloudy": "wi-night-alt-partly-cloudy",
            "partlysunny": "wi-night-alt-partly-cloudy",
            "rain": "wi-night-alt-rain",
            "sleet": "wi-night-alt-sleet",
            "snow": "wi-night-alt-snow",
            "tstorms": "wi-night-alt-thunderstorm"
        },

        moonPhaseTable: {
            "01": "wi-moon-new",
            "02": "wi-moon-waxing-crescent-1",
            "03": "wi-moon-waxing-crescent-2",
            "04": "wi-moon-waxing-crescent-3",
            "05": "wi-moon-waxing-crescent-4",
            "06": "wi-moon-waxing-crescent-5",
            "07": "wi-moon-waxing-crescent-6",
            "08": "wi-moon-first-quarter",
            "09": "wi-moon-waxing-gibbous-1",
            "10": "wi-moon-waxing-gibbous-2",
            "11": "wi-moon-waxing-gibbous-3",
            "12": "wi-moon-waxing-gibbous-4",
            "13": "wi-moon-waxing-gibbous-5",
            "14": "wi-moon-waxing-gibbous-6",
            "15": "wi-moon-full",
            "16": "wi-moon-waning-gibbous-1",
            "17": "wi-moon-waning-gibbous-2",
            "18": "wi-moon-waning-gibbous-3",
            "19": "wi-moon-waning-gibbous-4",
            "20": "wi-moon-waning-gibbous-5",
            "21": "wi-moon-waning-gibbous-6",
            "22": "wi-moon-third-quarter",
            "23": "wi-moon-waning-crescent-1",
            "24": "wi-moon-waning-crescent-2",
            "25": "wi-moon-waning-crescent-3",
            "26": "wi-moon-waning-crescent-4",
            "27": "wi-moon-waning-crescent-5",
            "28": "wi-moon-waning-crescent-6"
        }
    },

    // Define required translations.
    getTranslations: function () {
        return {
            en: "translations/en.json",
            nl: "translations/nl.json",
            de: "translations/de.json",
            dl: "translations/de.json",
            fr: "translations/fr.json",
            pl: "translations/pl.json"
            
        };
    },

    // Define required scripts.
    getScripts: function () {
        return ["moment.js"];
    },

    // Define required scripts.
    getStyles: function () {
        return ["weather-icons.css", "weather-icons-wind.css",
            "MMM-WunderGround.css"
        ];
    },

    // Define start sequence.
    start: function () {
        Log.info("Starting module: " + this.name);

        // Set locale.
        moment.locale(config.language);

        this.forecast = [];
        this.hourlyforecast = [];
        this.loaded = false;
        this.error = false;
        this.errorDescription = "";
        this.scheduleUpdate(this.config.initialLoadDelay);

        this.updateTimer = null;

    },

    // Override dom generator.
    getDom: function () {
        var wrapper = document.createElement("div");
        var f;
        var forecast;
        var iconCell;
        var icon;
        var maxTempCell;
        var minTempCell;
        var popCell;
        var mmCell;
        var hourCell;
        var dayCell;
        var startingPoint;
        var currentStep;
        var steps;



        if (this.config.apikey === "") {
            wrapper.innerHTML = this.translate("APIKEY") + this.name +
                ".";
            wrapper.className = "dimmed light small";
            return wrapper;
        }

        if (this.error) {
            wrapper.innerHTML = "Error: " + this.errorDescription;
            wrapper.className = "dimmed light small";
            return wrapper;
        }

        if (!this.loaded) {
            wrapper.innerHTML = this.translate("LOADING");
            wrapper.className = "dimmed light small";
            return wrapper;
        }

        var small = document.createElement("div");
        small.className = "normal medium";

        var windIcon = document.createElement("span");
        windIcon.className = "wi " + this.windSpeed;
        small.appendChild(windIcon);

        var spacer = document.createElement("span");
        spacer.innerHTML = " ";
        small.appendChild(spacer);
        small.appendChild(spacer);

        var windDirectionIcon = document.createElement("span");
        if (this.config.UseCardinals === 0) {
            windDirectionIcon.className = "wi wi-wind " + this.windDirection;
        } else {
            windDirectionIcon.innerHTML = this.windDirectionTxt;
        }
        small.appendChild(windDirectionIcon);

        spacer = document.createElement("span");
        spacer.innerHTML = " ";
        small.appendChild(spacer);

        spacer = document.createElement("span");
        spacer.innerHTML = " ";
        small.appendChild(spacer);

        var sunriseSunsetIcon = document.createElement("span");
        sunriseSunsetIcon.className = "wi dimmed " + this.sunriseSunsetIcon;
        small.appendChild(sunriseSunsetIcon);

        var sunriseSunsetTime = document.createElement("span");
        sunriseSunsetTime.innerHTML = " " + this.sunriseSunsetTime;
        small.appendChild(sunriseSunsetTime);

        small.appendChild(spacer);
        small.appendChild(spacer);

        var moonPhaseIcon = document.createElement("span");
        moonPhaseIcon.className = "wi dimmed " + this.moonPhaseIcon;
        small.appendChild(moonPhaseIcon);

        var large = document.createElement("div");
        large.className = "large light";

        var weatherIcon = document.createElement("span");
        weatherIcon.className = "wi " + this.weatherType;
        large.appendChild(weatherIcon);

        var temperature = document.createElement("span");
        temperature.className = "bright";
        temperature.innerHTML = " " + this.temperature + "°";
        large.appendChild(temperature);

        wrapper.appendChild(small);
        wrapper.appendChild(large);


        // Forecast table

        var table = document.createElement("table");
        table.className = "small";
        table.setAttribute("width", "25%");

        if (this.config.layout == "vertical") {

            var row = document.createElement("tr");
            table.appendChild(row);

            if (this.config.fctext == 1) {
                var forecastTextCell = document.createElement("td");
                forecastTextCell.className = "forecastText";
                forecastTextCell.setAttribute("colSpan", "10");
                forecastTextCell.innerHTML = this.forecastText;

                row.appendChild(forecastTextCell);
            }

            row = document.createElement("tr");

            var dayHeader = document.createElement("th");
            dayHeader.className = "day";
            dayHeader.innerHTML = "";
            row.appendChild(dayHeader);

            var iconHeader = document.createElement("th");
            iconHeader.className = "tableheader icon";
            iconHeader.innerHTML = "";
            row.appendChild(iconHeader);

            var maxtempHeader = document.createElement("th");
            maxtempHeader.className = "align-center bright tableheader";
            row.appendChild(maxtempHeader);

            var maxtempicon = document.createElement("span");
            maxtempicon.className = "wi wi-thermometer";
            maxtempHeader.appendChild(maxtempicon);


            var mintempHeader = document.createElement("th");
            mintempHeader.className = "align-center bright tableheader";
            row.appendChild(mintempHeader);

            var mintempicon = document.createElement("span");
            mintempicon.className = "wi wi-thermometer-exterior";
            mintempHeader.appendChild(mintempicon);


            var popiconHeader = document.createElement("th");
            popiconHeader.className = "align-center bright tableheader";
            popiconHeader.setAttribute("colSpan", "10");
            row.appendChild(popiconHeader);

            var popicon = document.createElement("span");
            popicon.className = "wi wi-umbrella";
            popicon.setAttribute("colSpan", "10");
            popiconHeader.appendChild(popicon);

            table.appendChild(row);

            if (this.config.hourly == 1) {
                for (f in this.forecast) {
                    forecast = this.hourlyforecast[f * this.config.hourlyinterval];

                    row = document.createElement("tr");
                    table.appendChild(row);

                    hourCell = document.createElement("td");
                    hourCell.className = "hour";
                    hourCell.innerHTML = forecast.hour;
                    row.appendChild(hourCell);

                    iconCell = document.createElement("td");
                    iconCell.className =
                        "align-center bright weather-icon";
                    row.appendChild(iconCell);

                    icon = document.createElement("span");
                    icon.className = "wi " + forecast.icon;
                    iconCell.appendChild(icon);

                    maxTempCell = document.createElement("td");
                    maxTempCell.innerHTML = forecast.maxTemp + "°";
                    maxTempCell.className = "align-right max-temp";
                    row.appendChild(maxTempCell);

                    minTempCell = document.createElement("td");
                    minTempCell.innerHTML = forecast.minTemp + "°";
                    minTempCell.className = "align-right min-temp";
                    row.appendChild(minTempCell);

                    popCell = document.createElement("td");
                    popCell.innerHTML = forecast.pop + "%";
                    popCell.className = "align-right pop";
                    row.appendChild(popCell);

                    mmCell = document.createElement("td");
                    if (this.config.units == "metric") {
                        mmCell.innerHTML = forecast.mm + "mm";
                        mmCell.className = "align-right mm";
                    } else {
                        mmCell.innerHTML = forecast.mm + "in";
                        mmCell.className = "align-right mm";

                    }
                    row.appendChild(mmCell);

                    if (f > this.config.hourlycount) {
                        break;
                    }


                }
            }


            for (f in this.forecast) {
                forecast = this.forecast[f];

                row = document.createElement("tr");
                table.appendChild(row);

                dayCell = document.createElement("td");
                dayCell.className = "day";
                dayCell.innerHTML = forecast.day;
                row.appendChild(dayCell);

                iconCell = document.createElement("td");
                iconCell.className = "align-center bright weather-icon";
                row.appendChild(iconCell);

                icon = document.createElement("span");
                icon.className = "wi " + forecast.icon;
                iconCell.appendChild(icon);

                maxTempCell = document.createElement("td");
                maxTempCell.innerHTML = forecast.maxTemp + "°";
                maxTempCell.className = "align-right max-temp";
                row.appendChild(maxTempCell);

                minTempCell = document.createElement("td");
                minTempCell.innerHTML = forecast.minTemp + "°";
                minTempCell.className = "align-right min-temp";
                row.appendChild(minTempCell);

                popCell = document.createElement("td");
                popCell.innerHTML = forecast.pop + "%";
                popCell.className = "align-right pop";
                row.appendChild(popCell);

                mmCell = document.createElement("td");
                if (this.config.units == "metric") {
                    mmCell.innerHTML = forecast.mm + "mm";
                    mmCell.className = "align-right mm";
                } else {
                    mmCell.innerHTML = forecast.mm + "in";
                    mmCell.className = "align-right mm";

                }
                row.appendChild(mmCell);

                if (this.config.fade && this.config.fadePoint < 1) {
                    if (this.config.fadePoint < 0) {
                        this.config.fadePoint = 0;
                    }
                    startingPoint = this.forecast.length * this.config.fadePoint;
                    steps = this.forecast.length - startingPoint;
                    if (f >= startingPoint) {
                        currentStep = f - startingPoint;
                        row.style.opacity = 1 - (1 / steps *
                            currentStep);
                    }
                }

            }


            wrapper.appendChild(table);

        } else {

            var fctable = document.createElement("div");
            fctable.appendChild(document.createElement("hr"));

            if (this.config.fctext == 1) {
                var row = document.createElement("tr");
                var forecastTextCell = document.createElement("td");

                forecastTextCell.className = "forecastText";
                forecastTextCell.setAttribute("colSpan", "10");
                forecastTextCell.innerHTML = this.forecastText;

                row.appendChild(forecastTextCell);
                table.appendChild(row);
                fctable.appendChild(table);
                fctable.appendChild(document.createElement("hr"));
            }

            table = document.createElement("table");
            table.className = "small";
            table.setAttribute("width", "25%");

            if (this.config.hourly == 1) {

                row_time = document.createElement("tr");
                row_icon = document.createElement("tr");
                row_temp = document.createElement("tr");
                row_pop = document.createElement("tr");

                for (f in this.forecast) {
                    forecast = this.hourlyforecast[f * this.config.hourlyinterval];

                    hourCell = document.createElement("td");
                    hourCell.className = "hour";
                    hourCell.innerHTML = forecast.hour;
                    row_time.appendChild(hourCell);


                    iconCell = document.createElement("td");
                    iconCell.className = "align-center bright weather-icon";
                    icon = document.createElement("span");
                    icon.className = "wi " + forecast.icon;
                    iconCell.appendChild(icon);
                    row_icon.appendChild(iconCell);

                    maxTempCell = document.createElement("td");
                    maxTempCell.innerHTML = forecast.maxTemp + "&deg;/" + forecast.minTemp + "&deg;";
                    maxTempCell.className = "hour";
                    row_temp.appendChild(maxTempCell);

                    mmCell = document.createElement("td");

                    if (this.config.units == "metric") {
                        mmCell.innerHTML = forecast.pop + "%/" + forecast.mm + "mm";
                        mmCell.className = "hour";
                    } else {
                        mmCell.innerHTML = forecast.pop + "%/" + forecast.mm + "in";
                        mmCell.className = "hour";

                    }

                    row_pop.appendChild(mmCell);

                    var nl = Number(f) + 1;
                    if (( nl % 4 ) === 0 ) {
                            table.appendChild(row_time);
                            table.appendChild(row_icon);
                            table.appendChild(row_temp);
                            table.appendChild(row_pop);
                            row_time = document.createElement("tr");
                            row_icon = document.createElement("tr");
                            row_temp = document.createElement("tr");
                            row_pop = document.createElement("tr");
                    }

                    if (f > this.config.hourlycount) {
                        break;
                    }
                }


                table.appendChild(row_time);
                table.appendChild(row_icon);
                table.appendChild(row_temp);
                table.appendChild(row_pop);
                fctable.appendChild(table);
                fctable.appendChild(document.createElement("hr"));

            }

            table = document.createElement("table");
            table.className = "small";
            table.setAttribute("width", "25%");

            row_time = document.createElement("tr");
            row_icon = document.createElement("tr");
            row_temp = document.createElement("tr");
            row_pop = document.createElement("tr");


            for (f in this.forecast) {
                forecast = this.forecast[f];

                dayCell = document.createElement("td");
                dayCell.className = "hour";
                dayCell.innerHTML = forecast.day;
                row_time.appendChild(dayCell);

                iconCell = document.createElement("td");
                iconCell.className = "align-center bright weather-icon";

                icon = document.createElement("span");
                icon.className = "wi " + forecast.icon;
                iconCell.appendChild(icon);

                row_icon.appendChild(iconCell);

                maxTempCell = document.createElement("td");
                maxTempCell.innerHTML = forecast.maxTemp + "&deg;/" + forecast.minTemp + "&deg;";
                maxTempCell.className = "hour";
                row_temp.appendChild(maxTempCell);

                mmCell = document.createElement("td");
                if (this.config.units == "metric") {
                    mmCell.innerHTML = forecast.pop + "%/" + forecast.mm + "mm";
                    mmCell.className = "hour";
                } else {
                    mmCell.innerHTML = forecast.pop + "%/" + forecast.mm + "in";
                    mmCell.className = "hour";

                }

                row_pop.appendChild(mmCell);
                
                var nl = Number(f) + 1;
                if (( nl % 4 ) === 0 ) {
                    table.appendChild(row_time);
                    table.appendChild(row_icon);
                    table.appendChild(row_temp);
                    table.appendChild(row_pop);
                    row_time = document.createElement("tr");
                    row_icon = document.createElement("tr");
                    row_temp = document.createElement("tr");
                    row_pop = document.createElement("tr");
                }

            }

            table.appendChild(row_time);
            table.appendChild(row_icon);
            table.appendChild(row_temp);
            table.appendChild(row_pop);
            fctable.appendChild(table);
            wrapper.appendChild(fctable);


        }
        return wrapper;

    },

    /* updateWeather(compliments)
     * Requests new data from openweather.org.
     * Calls processWeather on succesfull response.
     */
    updateWeather: function () {
        var url = this.config.apiBase + this.getParams();
        var self = this;
        var retry = true;

        var weatherRequest = new XMLHttpRequest();
        weatherRequest.open("GET", url, true);
        weatherRequest.onreadystatechange = function () {
            if (this.readyState === 4) {
                if (this.status === 200) {
                    self.processWeather(JSON.parse(this.response));
                } else if (this.status === 401) {
                    self.config.appid = "";
                    self.updateDom(self.config.animationSpeed);

                    Log.error(self.name + ": Incorrect APPID.");
                    retry = false;
                } else {
                    Log.error(self.name +
                        ":* Could not load weather.");
                }

                if (retry) {
                    self.scheduleUpdate((self.loaded) ? -1 :
                        self.config.retryDelay);
                }
            }
        };
        weatherRequest.send();
    },

    /* getParams(compliments)
     * Generates an url with api parameters based on the config.
     *
     * return String - URL params.
     */
    getParams: function () {
        var params = this.config.apikey;
        var wulang = this.config.lang.toUpperCase();
        if (wulang == "DE") {
            wulang = "DL";
        }
        params +=
            "/conditions/hourly/forecast10day/astronomy/alerts/lang:" +
            wulang;
        params += "/q/" + this.config.pws;
        params += ".json";

        console.log(params);


        return params;
    },

    /* processWeather(data)
     * Uses the received data to set the various values.
     *
     * argument data object - Weather information received form openweather.org.
     */

    processWeather: function (data) {

        if (data.response.hasOwnProperty("error")) {
            this.errorDescription = data.response.error.description;
            this.error = true;
            this.updateDom(this.config.animationSpeed);
        } else {
            this.error = false;
            var forecast;
            var i;
            var count;
            var iconTable = this.config.iconTableDay;
            this.alerttext = "";
            this.alertmsg = "";

            var now = new Date();

            var sunrise = new Date();
            this.sunrhour = Number(data.sun_phase.sunrise.hour);
            sunrise.setHours(data.sun_phase.sunrise.hour);
            sunrise.setMinutes(data.sun_phase.sunrise.minute);

            var sunset = new Date();
            this.sunshour = Number(data.sun_phase.sunset.hour);
            sunset.setHours(data.sun_phase.sunset.hour);
            sunset.setMinutes(data.sun_phase.sunset.minute);




            // The moment().format("h") method has a bug on the Raspberry Pi.
            // So we need to generate the timestring manually.
            // See issue: /~https://github.com/MichMich/MagicMirror/issues/181

            var sunriseSunsetDateObject = (sunrise < now && sunset >
                now) ? sunset : sunrise;
            var timeString = moment(sunriseSunsetDateObject).format(
                "HH:mm");

            if (this.config.timeFormat !== 24) {
                if (this.config.showPeriod) {
                    if (this.config.showPeriodUpper) {
                        timeString = moment(sunriseSunsetDateObject).format(
                            "h:mm A");
                    } else {
                        timeString = moment(sunriseSunsetDateObject).format(
                            "h:mm a");
                    }
                } else {
                    timeString = moment(sunriseSunsetDateObject).format(
                        "h:mm");
                }
            }

            this.sunriseSunsetTime = timeString;
            this.sunriseSunsetIcon = (sunrise < now && sunset > now) ?
                "wi-sunset" : "wi-sunrise";
            this.iconTable = (sunrise < now && sunset > now) ? this.config
                .iconTableDay : this.config.iconTableNight;


            for (i = 0, count = data.alerts.length; i < count; i++) {

                var talert = data.alerts[i].description;
                var malert = data.alerts[i].message;
                if (talert.length < malert.length) {
                    talert = malert;
                }
                if (this.config.alerttruncatestring !== "") {
                    var ialert = talert.indexOf(this.config.alerttruncatestring);
                    if (ialert > 0) {
                        talert = talert.substring(1, ialert);
                    }
                }
                this.alertmsg = this.alertmsg + talert;

                this.alerttext = this.alerttext + "<B style=\"color:" +
                    data.alerts[i].level_meteoalarm_name + "\">" + this
                    .translate(data.alerts[i].type) + "</B>";
                if (i < (count - 1)) {
                    this.alerttext = this.alerttext + "<BR>";
                }

            }

            if (this.alertmsg !== "") {
                this.sendNotification("SHOW_ALERT", {
                    type: "alert",
                    message: this.alertmsg,
                    title: this.alerttext,
                    timer: this.config.alerttime
                });
            }

            this.weatherType = this.iconTable[data.current_observation.icon];
            this.windDirection = this.deg2Cardinal(data.current_observation.wind_degrees);
            this.windDirectionTxt = data.current_observation.wind_dir;
            this.windSpeed = "wi-wind-beaufort-" + this.ms2Beaufort(data.current_observation.wind_kph);
            this.moonPhaseIcon = this.config.moonPhaseTable[data.moon_phase.ageOfMoon];


            if (this.config.units == "metric") {
                this.temperature = data.current_observation.temp_c;
                this.forecastText = this.wordwrap(data.forecast.txt_forecast
                    .forecastday[0].fcttext_metric, 30, "<BR>"); //  Wordwrap the text so it doesn"t mess up the display
            } else {
                this.temperature = data.current_observation.temp_f;
                this.forecastText = this.wordwrap(data.forecast.txt_forecast
                    .forecastday[0].fcttext, 30, "<BR>"); //  Wordwrap the text so it doesn"t mess up the display
            }

            this.temperature = this.roundValue(this.temperature);

            if (this.alerttext !== "") {
                this.forecastText = "<B>" + this.alerttext + "</B><BR>" +
                    this.forecastText;
            }


            this.forecast = [];
            for (i = this.config.fcdaystart, count = data.forecast.simpleforecast
                .forecastday.length; i < this.config.fcdaycount; i++) {

                forecast = data.forecast.simpleforecast.forecastday[i];

                if (this.config.units == "metric") {
                    this.tmaxTemp = forecast.high.celsius;
                    this.tminTemp = forecast.low.celsius;
                    this.tmm = forecast.qpf_allday.mm;
                } else {
                    this.tmaxTemp = forecast.high.fahrenheit;
                    this.tminTemp = forecast.low.fahrenheit;
                    this.tmm = forecast.qpf_allday.in;
                }

                this.maxTemp = this.roundValue(this.maxTemp);
                this.minTemp = this.roundValue(this.minTemp);


                this.forecast.push({

                    day: forecast.date.weekday_short,
                    maxTemp: this.tmaxTemp,
                    minTemp: this.tminTemp,
                    icon: this.config.iconTableDay[forecast.icon],
                    pop: forecast.pop,
                    mm: this.tmm
                });


            }

            if (this.config.hourly == 1) {
                this.hourlyforecast = [];
                for (i = 0, count = data.hourly_forecast.length; i <
                    count; i++) {

                    var hourlyforecast = data.hourly_forecast[i];

                    if (this.config.units == "metric") {
                        this.tmaxTemp = hourlyforecast.temp.metric;
                        this.tminTemp = hourlyforecast.feelslike.metric;
                        this.tmm = hourlyforecast.qpf.metric;
                        this.thour = hourlyforecast.FCTTIME.hour +
                            ":00";
                    } else {
                        this.tmaxTemp = hourlyforecast.temp.english;
                        this.tminTemp = hourlyforecast.feelslike.english;
                        this.tmm = hourlyforecast.qpf.english;
                        this.thour = hourlyforecast.FCTTIME.civil;
                    }
                    this.tthour = Number(hourlyforecast.FCTTIME.hour);
                    this.ForecastIcon = (this.sunrhour < this.tthour &&
                        this.sunshour > this.tthour) ? this.config.iconTableDay[
                        hourlyforecast.icon] : this.config.iconTableNight[
                        hourlyforecast.icon];

                    this.hourlyforecast.push({

                        hour: this.thour,
                        maxTemp: this.tmaxTemp,
                        minTemp: this.tminTemp,
                        icon: this.ForecastIcon,
                        pop: hourlyforecast.pop,
                        mm: this.tmm
                    });
                }
            }




            Log.log(this.forecast);

            this.loaded = true;
            this.updateDom(this.config.animationSpeed);
        }
    },

    /* scheduleUpdate()
     * Schedule next update.
     *
     * argument delay number - Milliseconds before next update. If empty, this.config.updateInterval is used.
     */
    scheduleUpdate: function (delay) {
        var nextLoad = this.config.updateInterval;
        if (typeof delay !== "undefined" && delay >= 0) {
            nextLoad = delay;
        }

        var self = this;
        clearTimeout(this.updateTimer);
        this.updateTimer = setTimeout(function () {
            self.updateWeather();
        }, nextLoad);
    },

    /* ms2Beaufort(ms)
     * Converts m2 to beaufort (windspeed).
     *
     * argument ms number - Windspeed in m/s.
     *
     * return number - Windspeed in beaufort.
     */
    ms2Beaufort: function (kmh) {
        var speeds = [1, 5, 11, 19, 28, 38, 49, 61, 74, 88, 102,
            117, 1000
        ];
        for (var beaufort in speeds) {
            var speed = speeds[beaufort];
            if (speed > kmh) {
                return beaufort;
            }
        }
        return 12;
    },

    wordwrap: function (str, width, brk) {

        brk = brk || "n";
        width = width || 75;

        if (!str) {
            return str;
        }

        var re = new RegExp(".{1," + width +
            "}(\\s|$)|\\ S+?(\\s|$)", "g");

        return str.match(RegExp(re)).join(brk);

    },

    /* function(temperature)
     * Rounds a temperature to 1 decimal.
     *
     * argument temperature number - Temperature.
     *
     * return number - Rounded Temperature.
     */

    deg2Cardinal: function (deg) {
        if (deg > 11.25 && deg <= 33.75) {
            return "wi-from-nne";
        } else if (deg > 33.75 && deg <= 56.25) {
            return "wi-from-ne";
        } else if (deg > 56.25 && deg <= 78.75) {
            return "wi-from-ene";
        } else if (deg > 78.75 && deg <= 101.25) {
            return "wi-from-e";
        } else if (deg > 101.25 && deg <= 123.75) {
            return "wi-from-ese";
        } else if (deg > 123.75 && deg <= 146.25) {
            return "wi-from-se";
        } else if (deg > 146.25 && deg <= 168.75) {
            return "wi-from-sse";
        } else if (deg > 168.75 && deg <= 191.25) {
            return "wi-from-s";
        } else if (deg > 191.25 && deg <= 213.75) {
            return "wi-from-ssw";
        } else if (deg > 213.75 && deg <= 236.25) {
            return "wi-from-sw";
        } else if (deg > 236.25 && deg <= 258.75) {
            return "wi-from-wsw";
        } else if (deg > 258.75 && deg <= 281.25) {
            return "wi-from-w";
        } else if (deg > 281.25 && deg <= 303.75) {
            return "wi-from-wnw";
        } else if (deg > 303.75 && deg <= 326.25) {
            return "wi-from-nw";
        } else if (deg > 326.25 && deg <= 348.75) {
            return "wi-from-nnw";
        } else {
            return "wi-from-n";
        }
    },

    /* function(temperature)
     * Rounds a temperature to 1 decimal.
     *
     * argument temperature number - Temperature.
     *
     * return number - Rounded Temperature.
     */
    roundValue: function (temperature) {
        return parseFloat(temperature).toFixed(this.config.roundTmpDecs);
    }
});