Add support for weather forecast

sharky76 · sharky76 · commit 753f94a20203 · 2017-02-21T08:57:38.000-06:00
diff --git a/libZaeUtil/stack.h b/libZaeUtil/stack.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "variant.h"
+#include <sys/param.h>
 // This is the basic stack implementation for holding operands and operators
 
 typedef struct stack_item_t
@@ -22,6 +23,11 @@ int __i__;  \
 variant_t* _value = stack_peek_at(_stack, 0);  \
 for(__i__ = 0; __i__ < _stack->count; __i__++, _value = stack_peek_at(_stack, __i__))   \
 
+#define stack_for_each_range(_stack, _from, _to, _value)  \
+int __i__;  \
+variant_t* _value = stack_peek_at(_stack, 0);  \
+for(__i__ = _from; __i__ <= MIN(_stack->count-1, _to); __i__++, _value = stack_peek_at(_stack, __i__))   \
+
 variant_stack_t*        stack_create();
 void            stack_free(variant_stack_t* stack);
 void            stack_empty(variant_stack_t* stack);
diff --git a/services/Weather/Weather.c b/services/Weather/Weather.c
@@ -19,6 +19,7 @@ void    service_create(service_t** service, int service_id)
     SERVICE_ADD_METHOD(GetPrecipitation,    weather_get_precipitation, 0, "Get current precipitation");
     SERVICE_ADD_METHOD(GetHumidity,         weather_get_humidity, 0, "Get current humidity");
     SERVICE_ADD_METHOD(Refresh,             weather_refresh_cache, 0, "Update stored weather information");
+    SERVICE_ADD_METHOD(GetForecast,         weather_get_forecast, 1, "Return weather forecast, args: Hourly|Daily|Raw");
 
     (*service)->get_config_callback = weather_cli_get_config;
     DT_WEATHER = service_id;
diff --git a/services/Weather/weather_cache.c b/services/Weather/weather_cache.c
@@ -10,6 +10,9 @@
 
 weather_cache_t  weather_cache;
 void    weather_cache_parse_response(struct json_object* weather_response_obj);
+void    weather_cache_parse_forecast(struct json_object* weather_response_obj);
+void    weather_cache_parse_weather_entry(struct json_object* weather_entry_obj, weather_cache_t* cache_entry);
+void    weather_entry_free(void* arg);
 
 typedef struct response_memory_t 
 {
@@ -43,6 +46,8 @@ void weather_cache_init()
     weather_cache.windspeed = 0;
     weather_cache.temp = 0;
     weather_cache.precipitation = NULL;
+    weather_cache.raw_forecast = NULL;
+    weather_cache.forecast_hourly = stack_create();
 }
 
 void    weather_cache_refresh()
@@ -103,6 +108,43 @@ void    weather_cache_refresh()
         json_object_put(weather_response_obj);
     }
     
+    // Now get the forecast
+    free(chunk.memory);
+    chunk.memory = malloc(1);  /* will be grown as needed by the realloc above */ 
+    chunk.size = 0;    /* no data at this point */ 
+
+    snprintf(urlbuf, 511, "http://api.openweathermap.org/data/2.5/forecast?zip=%d,%s&units=%s&APPID=%s", weather_zip, weather_country_code, weather_temp_units, "337b07da05ad8ebf391e2252f02196cf");
+
+    LOG_DEBUG(DT_WEATHER, "Weather URL %s", urlbuf);
+
+    curl_easy_setopt(curl_handle, CURLOPT_URL, urlbuf);
+    
+    /* send all data to this function  */ 
+    curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, write_cb);
+    
+    /* we pass our 'chunk' struct to the callback function */ 
+    curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *)&chunk);
+    
+    /* some servers don't like requests that are made without a user-agent
+    field, so we provide one */ 
+    curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, "libcurl-agent/1.0");
+    
+    /* get it! */ 
+    res = curl_easy_perform(curl_handle);
+    
+    /* check for errors */ 
+    if(res != CURLE_OK) 
+    {
+        LOG_ERROR(DT_WEATHER, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
+    }
+    else 
+    {
+        LOG_DEBUG(DT_WEATHER, "%lu bytes retrieved", (long)chunk.size);
+        struct json_object* weather_response_obj = json_tokener_parse(chunk.memory);
+        weather_cache_parse_forecast(weather_response_obj);
+        json_object_put(weather_response_obj);
+    }
+
     /* cleanup curl stuff */ 
     curl_easy_cleanup(curl_handle);
     
@@ -118,7 +160,49 @@ void    weather_cache_parse_response(struct json_object* weather_response_obj)
     free(weather_cache.precipitation);
     weather_cache.precipitation = 0;
 
-    json_object_object_foreach(weather_response_obj, key, value)
+    weather_cache_parse_weather_entry(weather_response_obj, &weather_cache);
+
+    LOG_DEBUG(DT_WEATHER, "Updated weather values - precipitation: %s, temp: %f, humidity: %d, wind: %f", 
+           weather_cache.precipitation,
+           weather_cache.temp,
+           weather_cache.humidity,
+           weather_cache.windspeed);
+}
+
+void    weather_cache_parse_forecast(struct json_object* weather_response_obj)
+{
+    //printf("jobj from str:\n---\n%s\n---\n", json_object_to_json_string_ext(weather_response_obj, JSON_C_TO_STRING_SPACED | JSON_C_TO_STRING_PRETTY));
+    stack_empty(weather_cache.forecast_hourly);
+
+    free(weather_cache.raw_forecast);
+    
+    json_object* entries_array;
+    json_object_object_get_ex(weather_response_obj, "list", &entries_array);
+    int weather_entries = json_object_array_length(entries_array);
+
+    for(int i = 0; i < weather_entries; i++)
+    {
+        json_object* entry = json_object_array_get_idx(entries_array, i);
+        json_object* date_obj;
+        json_object_object_get_ex(entry, "dt", &date_obj);
+
+        weather_forecast_cache_t* forecast_entry = calloc(1, sizeof(weather_forecast_cache_t));
+        forecast_entry->timestamp = json_object_get_int(date_obj);
+
+        weather_cache_parse_weather_entry(entry, &forecast_entry->weather_entry);
+
+        variant_t* forecast_entry_variant = variant_create_ptr(DT_PTR, forecast_entry, &weather_entry_free);
+        stack_push_back(weather_cache.forecast_hourly, forecast_entry_variant);
+    }
+
+    weather_cache.raw_forecast = strdup(json_object_to_json_string_ext(weather_response_obj, JSON_C_TO_STRING_SPACED | JSON_C_TO_STRING_PRETTY));
+}
+
+void    weather_cache_parse_weather_entry(struct json_object* weather_entry_obj, weather_cache_t* cache_entry)
+{
+    cache_entry->precipitation = 0;
+
+    json_object_object_foreach(weather_entry_obj, key, value)
     {
         if(strcmp(key, "weather") == 0)
         {
@@ -131,19 +215,19 @@ void    weather_cache_parse_response(struct json_object* weather_response_obj)
                 {
                     const char* weather_string = json_object_get_string(weather_value);
                     int old_len = 0;
-                    if(NULL != weather_cache.precipitation)
+                    if(NULL != cache_entry->precipitation)
                     {
-                        old_len = strlen(weather_cache.precipitation);
+                        old_len = strlen(cache_entry->precipitation);
                     }
-                    weather_cache.precipitation = realloc(weather_cache.precipitation, (old_len + 2 + strlen(weather_string))*sizeof(char));
-                    if(NULL != weather_cache.precipitation)
+                    cache_entry->precipitation = realloc(cache_entry->precipitation, (old_len + 2 + strlen(weather_string))*sizeof(char));
+                    if(NULL != cache_entry->precipitation)
                     {
-                        memset(weather_cache.precipitation + (old_len), 0, 2 + strlen(weather_string));
-                        strcat(weather_cache.precipitation, weather_string);
+                        memset(cache_entry->precipitation + (old_len), 0, 2 + strlen(weather_string));
+                        strcat(cache_entry->precipitation, weather_string);
 
                         if(i < weather_entries-1)
                         {
-                            strcat(weather_cache.precipitation, "|");
+                            strcat(cache_entry->precipitation, "|");
                         }
                     }
                 }
@@ -154,28 +238,30 @@ void    weather_cache_parse_response(struct json_object* weather_response_obj)
             struct json_object* temp_data;
             if(json_object_object_get_ex(value, "temp", &temp_data) == TRUE)
             {
-                weather_cache.temp = json_object_get_double(temp_data);
+                cache_entry->temp = json_object_get_double(temp_data);
             }
             struct json_object* humidity_data;
             if(json_object_object_get_ex(value, "humidity", &humidity_data) == TRUE)
             {
-                weather_cache.humidity = json_object_get_int(humidity_data);
+                cache_entry->humidity = json_object_get_int(humidity_data);
             }
         }
         else if(strcmp(key, "wind") == 0)
         {
             struct json_object* wind_data;
             if(json_object_object_get_ex(value, "speed", &wind_data) == TRUE)
             {
-                weather_cache.windspeed = json_object_get_double(wind_data);
+                cache_entry->windspeed = json_object_get_double(wind_data);
             }
         }
     }
-
-    LOG_DEBUG(DT_WEATHER, "Updated weather values - precipitation: %s, temp: %f, humidity: %d, wind: %f", 
-           weather_cache.precipitation,
-           weather_cache.temp,
-           weather_cache.humidity,
-           weather_cache.windspeed);
 }
 
+void    weather_entry_free(void* arg)
+{
+    weather_forecast_cache_t* entry = (weather_forecast_cache_t*)arg;
+    free(entry->weather_entry.precipitation);
+    free(entry->weather_entry.raw_forecast);
+    stack_free(entry->weather_entry.forecast_hourly);
+    free(entry);
+}
diff --git a/services/Weather/weather_cache.h b/services/Weather/weather_cache.h
@@ -1,3 +1,6 @@
+#include "stack.h"
+#include <time.h>
+
 typedef struct weather_cache_t
 {
     int cache_age;
@@ -6,8 +9,16 @@ typedef struct weather_cache_t
     double  windspeed;
     char*   precipitation;
     int     humidity;
+    char*   raw_forecast;
+    variant_stack_t* forecast_hourly;
 } weather_cache_t;
 
+typedef struct weather_forecast_cache_t
+{
+    time_t timestamp;
+    weather_cache_t weather_entry;
+} weather_forecast_cache_t;
+
 extern weather_cache_t  weather_cache;
 
 void    weather_cache_init();
diff --git a/services/Weather/weather_methods.c b/services/Weather/weather_methods.c
@@ -1,5 +1,7 @@
 #include "weather_methods.h"
 #include "weather_cache.h"
+#include <stdio.h>
+#include <time.h>
 
 variant_t*  weather_get_temp(service_method_t* method, va_list args)
 {
@@ -37,3 +39,66 @@ variant_t*  weather_get_humidity(service_method_t* method, va_list args)
     return variant_create_int32(DT_INT32, weather_cache.humidity);
 }
 
+variant_t*  weather_get_forecast(service_method_t* method, va_list args)
+{
+    weather_cache_refresh();
+    variant_t* range_variant = va_arg(args, variant_t*);
+    char* range;
+    variant_to_string(range_variant, &range);
+    
+    char* formatted_output = NULL;
+    if(NULL != range)
+    {
+        if(0 == strcmp(range, "Hourly") && weather_cache.forecast_hourly->count > 0)
+        {
+            stack_for_each_range(weather_cache.forecast_hourly, 0, 8, forecast_entry_variant)
+            {
+                weather_forecast_cache_t* forecast_entry = VARIANT_GET_PTR(weather_forecast_cache_t, forecast_entry_variant);
+                //variant_t* vv = variant_create_float(forecast_entry->weather_entry.temp);
+                char time_string[256] = {0};
+                struct tm* time_tm = localtime(&forecast_entry->timestamp);
+                size_t time_size = strftime(time_string, 255, "%l%P", time_tm);
+
+                int old_len = 0;
+                if(NULL != formatted_output)
+                {
+                    old_len = strlen(formatted_output);
+                }
+
+                formatted_output = realloc(formatted_output, old_len + 255);
+                snprintf(formatted_output+old_len, 254, "%s %.1fF %s\n", time_string, forecast_entry->weather_entry.temp, forecast_entry->weather_entry.precipitation);
+            }
+            return variant_create_string(formatted_output);
+        }
+        else if(0 == strcmp(range, "Daily") && weather_cache.forecast_hourly->count > 0)
+        {
+            stack_for_each(weather_cache.forecast_hourly, forecast_entry_variant)
+            {
+                weather_forecast_cache_t* forecast_entry = VARIANT_GET_PTR(weather_forecast_cache_t, forecast_entry_variant);
+                //variant_t* vv = variant_create_float(forecast_entry->weather_entry.temp);
+                char time_string[256] = {0};
+                struct tm* time_tm = localtime(&forecast_entry->timestamp);
+                size_t time_size = strftime(time_string, 255, "%a %e %l%P", time_tm);
+
+                int old_len = 0;
+                if(NULL != formatted_output)
+                {
+                    old_len = strlen(formatted_output);
+                }
+
+                formatted_output = realloc(formatted_output, old_len + 255);
+                snprintf(formatted_output+old_len, 254, "%s %.1fF %s\n", time_string, forecast_entry->weather_entry.temp, forecast_entry->weather_entry.precipitation);
+            }
+            return variant_create_string(formatted_output);
+        }
+        else if(0 == strcmp(range, "Raw") && NULL != weather_cache.raw_forecast)
+        {
+            return variant_create_string(strdup(weather_cache.raw_forecast));
+        }
+        else
+        {
+            return variant_create_string(strdup("no data"));
+        }
+    }
+    return NULL;
+}
diff --git a/services/Weather/weather_methods.h b/services/Weather/weather_methods.h
@@ -5,4 +5,4 @@ variant_t*  weather_get_windspeed(service_method_t* method, va_list args);
 variant_t*  weather_get_precipitation(service_method_t* method, va_list args);
 variant_t*  weather_refresh_cache(service_method_t* method, va_list args);
 variant_t*  weather_get_humidity(service_method_t* method, va_list args);
-
+variant_t*  weather_get_forecast(service_method_t* method, va_list args);
diff --git a/vty_io.c b/vty_io.c
@@ -8,7 +8,7 @@
 #include <stdbool.h>
 #include "http_server.h"
 
-#define BUFSIZE 8096
+#define BUFSIZE 64000
 
 void    file_write_cb(vty_t* vty, const char* format, va_list args);
 char*   file_read_cb(vty_t* vty);
