using log4net;

using log4net.Appender;

using log4net.Repository.Hierarchy;

using Newtonsoft.Json;

using System;

using System.Collections.Generic;

using System.IO;

using System.Net.Http;

using System.Net.Http.Headers;

using System.Threading.Tasks;

​

/// <summary>

/// Application to provide a 5 day weather forecast for a list of locations

/// Using weather service available at http://api.openweathermap.org

/// </summary>

/// <remarks>

/// Using separate api key for each location as weather service requires 10 minute delay  between request for an api key 

/// </remarks>

namespace DCU_Weather_App

{

    public class DCU_Weather_App

    {

        #region main

        public static void Main(string[] args)

        {

            RestRequestHandler apiHandler = new RestRequestHandler();

​

            // Configure Logging 

            Logger root;

            root = ((Hierarchy)LogManager.GetRepository()).Root;

            root.AddAppender(GetConsoleAppender());

            root.Level = log4net.Core.Level.All;

            root.Repository.Configured = true;

            ILog log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

            log.Debug("Logger configured.");

​

            // Get list of locations

            List<Location> places = GetPlacesOfInterest();

​

            // Setup Weather Service 

            string temperatureUnitHeading = "F";

            string temperatureUnit = "imperial";

            string serviceUri = "http://api.openweathermap.org/";

            WeatherService service = new WeatherService(temperatureUnit, serviceUri, apiHandler);

​

            // Loop over locations , polling for weather forecast, then print forecast       

            foreach (Location place in places)

            {

                log.DebugFormat("Requesting 5 day forecast for {0}", place.ToString());

                try

                {

                    // get weather forecast

                    List<DailyForecast> fiveDayForecast = service.GetFiveDayForecast(place);

                    PrintFiveDayForecast(temperatureUnitHeading, place, fiveDayForecast);

                }

                catch (ForecastException )

                {

                    PrintFiveDayForecast(temperatureUnitHeading, place, null);

                }

                catch (JsonSerializationException )

                {

                    PrintFiveDayForecast(temperatureUnitHeading, place, null);

                }

​

            }

​

        }

​

        /// <summary>

        /// Output Five Day forecast for a location

        /// </summary>

        /// <param name="temperatureUnitHeading"></param>

        /// <param name="place">Location information</param>

        /// <param name="fiveDayForecast">Collection containing forecast information</param>

        private static void PrintFiveDayForecast(string temperatureUnitHeading, Location place, List<DailyForecast> fiveDayForecast)

        {

            Console.WriteLine("________________________________");

            Console.WriteLine(place.ToString());

            Console.WriteLine();

            Console.WriteLine("Date       Avg Temp ({0})", temperatureUnitHeading);

            Console.WriteLine("--------------------------------");

            if (fiveDayForecast != null && fiveDayForecast.Count > 0)

            {

                // fiveDayForecast can contain 6 days, so use for loop rather than foreach

                for (int i = 0; i < 5; i++)

                {

                    Console.WriteLine(fiveDayForecast[i].ToString());

                }

            } 

            else

            {

                Console.WriteLine("Forecast not available.");

            }

            // space between locations

            Console.WriteLine();

            Console.WriteLine();

        }

​

        /// <summary>

        /// Initial list of locations

        /// </summary>

        /// <returns>List of location information</returns>

        private static List<Location> GetPlacesOfInterest()

        {

            //TODO see if there is a location id associated with each place. See section "By City ID" at http://openweathermap.org/forecast5

            List<Location> places = new List<Location>();

            places.Add(new Location("Marlborough", "MA", "US", "01752", 0, "5e29182a06c63b5f602678a726e792fd"));

            places.Add(new Location("San Diego", "CA", "US", "92101", 0, "bf24ba3f36d441c256e1b273c09907b4"));

            places.Add(new Location("Cheyenne", "WY", "US", "82001", 0, "9d301f9f938122e2cb2761fc6f1aeb44"));

            places.Add(new Location("Anchorage", "AK", "US", "99501", 0, "9d301f9f938122e2cb2761fc6f1aeb44"));

            places.Add(new Location("Austin", "TX", "US", "78701", 0, "100c9e8d324f793a3193472c7ce67cdc"));

            places.Add(new Location("Orlando", "FL", "US", "32801", 0, "e6b773396aa847aa6e5781e7dd73f690"));

            places.Add(new Location("Seattle", "WA", "US", "98101", 0, "a526352b22c8029e97710b86fb86214b"));

            places.Add(new Location("Cleveland", "OH", "US", "44101", 0, "43ed1dc91611eceb140443bcd2d2ef15"));

            places.Add(new Location("Portland", "ME", "US", "04101", 0, "c5d5f4ee0d98ca4abd2794d9916ac294"));

            places.Add(new Location("Honolulu", "HI", "US", "96801", 0, "5395607abfce7204d1c0302e12242590"));

​

            return places;

        }

        /// <summary>

        /// Get Log4Net Appender to Console

        /// </summary>

        /// <returns></returns>

        private static ConsoleAppender GetConsoleAppender()

        {

            ConsoleAppender lAppender = new ConsoleAppender();

            lAppender.Name = "Console";

            lAppender.Layout = new log4net.Layout.PatternLayout("%date{dd-MM-yyyy HH:mm:ss,fff} %5level [%2thread] %message (%logger{1}:%line)%n");

            lAppender.Threshold = log4net.Core.Level.Error;

            lAppender.ActivateOptions();

​

            return lAppender;

        }

​

    }

    #endregion main

    #region services

    /// <summary>

    ///  Obtain weather forecast

    /// </summary>

    public class WeatherService

    {

​

        private static readonly ILog log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

        // methods provided by weather service

        private static readonly string PathFiveDayMethod = "data/2.5/forecast";

​

        // Desired units for Temperature, valid values depends upon weather service

        private string TemperatureUnit;

        private string TemperatureUnitLabel;

        /// <summary>

        /// Make service address property to support different environments -  such as using http vs https, or if dev/qua/uat instances were available

        /// </summary>

        public string ServiceAddress { get; set; }

        /// <summary>

        /// Http handler for submitting Restful API calls

        /// </summary>

        public RestRequestHandler ApiHandler { get; set; }

​

        /// <summary>

        /// default constructor

        /// </summary>

        public WeatherService()

        {

            TemperatureUnit = string.Empty; // Default units is Kelvin

            TemperatureUnitLabel = "K";

        }

​

        /// <summary>

        /// Initializing constructor

        /// </summary>

        /// <param name="temperatureUnit"></param>

        /// <param name="serviceAddress"></param>

        /// <param name="apiHandler"></param>

        public WeatherService(string temperatureUnit, string serviceAddress, RestRequestHandler apiHandler)

        {

            string temperatureUnitCleansed = temperatureUnit.ToLower();

            TemperatureUnit = temperatureUnitCleansed;

            // if not one of expected units, default to Kelvin

            switch (TemperatureUnit)

            {

                case "imperial":

                    TemperatureUnit = temperatureUnitCleansed;

                    TemperatureUnitLabel = "F";

                    break;

                case "metric":

                    TemperatureUnit = temperatureUnitCleansed;

                    TemperatureUnitLabel = "C";

                    break;

                default:

                    TemperatureUnit = "";

                    TemperatureUnitLabel = "K";

                    break;

            }

            ServiceAddress = serviceAddress;

            ApiHandler = apiHandler;

​

        }

​

        /// <summary>

        /// Get 5 day 3 hour forecast for a location

        /// </summary>

        /// <param name="location"></param>

        /// <returns></returns>

        public List<DailyForecast> GetFiveDayForecast(Location location)

        {

            //build url akin to : api.openweathermap.org/data/2.5/forecast?zip=01752&units=imperial&APPID=f008581d70e69a3b8a40051b8e72a8f7

            string url = string.Format("{0}{1}?zip={2}&APPID={3}&units={4}", ServiceAddress, PathFiveDayMethod, location.ZipCode, location.ApiKey, TemperatureUnit);

            // TODO switch to using location ids for improved accuracy

            //string url = string.Format("{0}/{1}?id={2}&APPID={3}&units={4}", ServiceAddress , PathFiveDayMethod, location.LocationId, location.ApiKey, TemperatureUnit);

            try

            {

                string responseData =  ApiHandler.ExecuteMethodAsGet(url, "application/json");

                FiveDayForecastRawData rawData = SerializeFiveDayForecast(responseData);

                log.Debug(rawData.ToString());

​

                // derive daily forecast for each of the 5 days

                List<DailyForecast> fiveDayForecast = GenerateDailyAverages(rawData);

                return fiveDayForecast;

            }

            catch (HttpRequestException ex)

            {

                log.ErrorFormat("Unable to acquire 5 day forecast for {0}. Url: {4} {1}:{2} {3}",

                        location.ToString(), ex.GetType().Name, ex.Message, ex.InnerException != null ? ex.InnerException.Message : "", url);

                string msg = string.Format("Unable to obtain forecast for {0}. Url:{1}", location.ToString(), url);

                throw new ForecastException(msg, ex, url);

                throw;

            }

            catch (JsonException ex)

            {

                string msg = string.Format("Unable to deserialize forecast for {0}", location.ToString());

                log.ErrorFormat("{0}. {1}:{2} ", msg, ex.GetType().Name, ex.Message);

​

                throw new ForecastException(msg, ex, url);

            }

        }

​

​

        /// <summary>

        /// Convert 5 Day 3 hour forecast data into daily averages

        /// </summary>

        /// <param name="incrementalForecast"></param>

        /// <param name="rawForecast"></param>

        /// <param name="temperatureUnit">Units for temperature, e.g. F, C, or K</param>

        /// <returns></returns>

        /// <remarks>

        /// Details on 5 day weather forecast api method at http://openweathermap.org/forecast5

        /// </remarks>

        private List<DailyForecast> GenerateDailyAverages(FiveDayForecastRawData rawForecast)

        {

            List<DailyForecast> fiveDayForecast = new List<DailyForecast>();

​

            // Sort raw data into date buckets so we can easily calculate daily averages

            Dictionary<DateTime, List<ForecastUnit>> dailyForecasts = new Dictionary<DateTime, List<ForecastUnit>>();

            foreach (ForecastUnit unit in rawForecast.list)

            {

                DateTime day = unit.dt_txt.Date;

                // see if date is in collection, if not add it

                if (!dailyForecasts.ContainsKey(day))

                {

                    dailyForecasts.Add(day, new List<ForecastUnit>());

                }

                // insert timeunit's foreacast to the day's list

                List<ForecastUnit> forecasts = dailyForecasts[day];

                forecasts.Add(unit);

                dailyForecasts[day] = forecasts;

​

            }

​

            foreach (DateTime day in dailyForecasts.Keys)

            {

​

                bool rainPredicted = false;

                double sumTemp = 0;

                int countMeasurements = 0;

​

                DailyForecast daysForecast = new DailyForecast();

                foreach (ForecastUnit unit in dailyForecasts[day])

                {

                    // OR rain conditions to determine possibility of rain

                    rainPredicted = rainPredicted || CheckForRain(unit.weather[0].id);

                    countMeasurements += 1;

                    sumTemp += unit.main.temp;

                }

                daysForecast.RainPredicted = rainPredicted;

                daysForecast.AverageTemperature = Math.Round(sumTemp / countMeasurements, 2);

                daysForecast.TemperatureUnits = this.TemperatureUnitLabel;

                // get date from first forecast in list 

                daysForecast.ForecastDate = day;

                fiveDayForecast.Add(daysForecast);

            }

​

            return fiveDayForecast;

        }

​

        /// <summary>

        /// Parse data provided by 5 day incremental forecast into object

        /// </summary>

        /// <param name="serializedForecast">Content of the 5 Day Forecast response</param>

        /// <returns>Deserialized version of content</returns>

        private FiveDayForecastRawData SerializeFiveDayForecast(string serializedForecast)

        {

            FiveDayForecastRawData rawForecast = null;

            StringReader sr = new StringReader(serializedForecast);

            try

            {

                JsonSerializer serializer = new JsonSerializer();

                rawForecast = (FiveDayForecastRawData)serializer.Deserialize(sr, typeof(FiveDayForecastRawData));

            }

            catch (JsonException ex)

            {

                log.ErrorFormat("Unable to deserialize file content. {0}", ex.Message);

                throw ;

            }

            return rawForecast;

​

        }

​

        /// <summary>

        /// Provide evaluation of condition codes used by weather service

        /// </summary>

        private bool CheckForRain(int conditionCode)

        {

            return conditionCode >= 500 && conditionCode < 600;

        }

    }

​

    /// <summary>

    /// Handler to make Rest API calls

    /// </summary>

    /// <remarks>

    /// according to this article,declare httpclient once and reuse rather than put into a using block: https://aspnetmonsters.com/2016/08/2016-08-27-httpclientwrong/

    /// </remarks>

    public class RestRequestHandler : IDisposable

    {

        ILog log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

​

        // HttpClient is designed to be reused, advantageous for configuring default request headers for authorization, etc.

        private HttpClient client;

        /// <summary>

        /// Constructor - no authorization headers

        /// </summary>

        public RestRequestHandler()

        {

​

            client = new HttpClient();

​

        }

​

        /// <summary>

        /// 

        /// </summary>

        /// <param name="url">url to submit as HTTP request</param>

        /// <param name="responseMediaType">Expected format of response, eg "application/json"</param>

        /// <returns>Response content</returns>

        public string ExecuteMethodAsGet(string url, string responseMediaType)

        {

            string data = string.Empty;

            try

            {

                //  client.BaseAddress = baseAddress;

                client.DefaultRequestHeaders.Accept.Clear();

                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(responseMediaType));

​

                HttpResponseMessage response =  client.GetAsync(url).Result;

                {

                    response.EnsureSuccessStatusCode();

                    data = response.Content.ReadAsStringAsync().Result;

                }

            }

            catch (HttpRequestException ex)

            {

                log.DebugFormat("Unsuccessful request: {0}. {1}:{2}", url, ex.GetType().Name, ex.Message);

                throw ex;

            }

​

            return data;

        }

        /// <summary>

        /// Dispose - called by .Net

        /// </summary>

        public void Dispose()

        {

            // If this function is being called the user wants to release the

            // resources. lets call the Dispose which will do this for us.

            Dispose(true);

​

            // Now since we have done the cleanup already there is nothing left

            // for the Finalizer to do. So lets tell the GC not to call it later.

            GC.SuppressFinalize(this);

        }

​

        /// <summary>

        /// Manage disposal of instance objects

        /// </summary>

        /// <param name="disposing"></param>

        protected virtual void Dispose(bool disposing)

        {

            if (disposing == true)

            {

                //someone want the deterministic release of all resources

                //Let us release all the managed resources

                client.Dispose();

            }

            else

            {

                // Do nothing, no one asked a dispose, the object went out of

                // scope and finalized is called so lets next round of GC 

                // release these resources

            }

​

        }

​

    }

    #endregion Services

    #region Model Classes

    /// <summary>

    /// Location - place of interest for weather monitoring

    /// </summary>

    public class Location

    {

        /// <summary>

        /// Zip code 

        /// </summary>

        public string ZipCode { get; set; }

        /// <summary>

        /// City name

        /// </summary>

        public string City { get; set; }

        /// <summary>

        /// State

        /// </summary>

        public string State { get; set; }

        /// <summary>

        /// Country associated with location

        /// </summary>

        public string Country { get; set; }

        /// <summary>

        /// Location id assigned by openweathermap.org, recommended identifier to use

        /// </summary>

        public int LocationId { get; set; }

        /// <summary>

        /// API key for connecting to weather service, Service restricts use of a api key to 10 min delay between requests, so use different api key for each location

        /// </summary>

        public string ApiKey { get; set; }

​

        /// <summary>

        /// Format header

        /// </summary>

        /// <returns> Formatted header: City, State (ZipCode)</returns>

        override

        public String ToString()

        {

            return string.Format("{0}, {1} ({2})", City, State, ZipCode);

        }

​

        /// <summary>

        /// Default Constructor

        /// </summary>

        public Location()

        {

​

        }

​

        /// <summary>ocation

        /// Initializing Constructor

        /// </summary>

        /// <param name="city"></param>

        /// <param name="state"></param>

        /// <param name="country"></param>

        /// <param name="zipCode"></param>

        /// <param name="locationId"></param

        /// <param name="apiKey">ApiKey for connecting to weather service</param>

        public Location(string city, string state, string country, string zipCode, int locationId, string apiKey)

        {

            City = city;

            State = state;

            Country = country;

            ZipCode = zipCode;

            LocationId = locationId;

            ApiKey = apiKey;

        }

    }

    /// <summary>

    /// Forecast - weather predictions for a date

    /// </summary>

    public class DailyForecast

    {

​

        /// <summary>

        /// Date for the weather forecast

        /// </summary>

        public DateTime ForecastDate { get; set; }

        /// <summary>

        /// Rain indicator: Set to true is rain is predicted

        /// </summary>

        public bool RainPredicted { get; set; }

        /// <summary>

        /// Average expected temperature

        /// </summary>

        public double AverageTemperature { get; set; }

        /// <summary>

        /// temperature units of scale: F: Fahrenheit, K: Kelvin, C: Celsius

        /// </summary>

        public string TemperatureUnits { get; set; }

​

        /// <summary>

        /// Format day's forecast  as Date Temp (Unit)

        /// </summary>

        /// <returns></returns>

        override

        public string ToString()

        {

            // TODO fix alignment of rain indicator for varying length date values

            string annotatedDate = string.Format("{0}{1}", ForecastDate.ToString("d").PadLeft(10), RainPredicted ? "*" : " ").TrimStart();

            return string.Format("{0} {1:0.00} {2}", annotatedDate, AverageTemperature, TemperatureUnits);

​

//            return string.Format("{0}{1} {2:0.00} {3}", ForecastDate.ToString("d").PadRight(10), RainPredicted ? "*" : " ", AverageTemperature, TemperatureUnits);

        }

    }

    /// <summary>

    /// WeatherData -  Data provided by weather service for 5 day forecast

    /// </summary>

    /// <remarks>

    /// Details on data structure available at http://openweathermap.org/forecast5

    /// For this exercise only extracting fields of interest.

    /// </remarks>

    public class FiveDayForecastRawData

    {

        /// <summary>

        /// Weather Service's internal code, looks like a HTTP status code

        /// </summary>

        public int cod { get; set; }

        /// <summary>

        /// Weather Service's parameter 

        /// </summary>

        public string message { get; set; }

​

        /// <summary>

        /// length of property list, number of time units provided

        /// </summary>

        public int cnt { get; set; }

        /// <summary>

        /// Collection of forecasts for the 5 days in 3 hour time increments

        /// </summary>

​

        public List<ForecastUnit> list { get; set; }

        /// <summary>

        /// Format object for printing

        /// </summary>

        /// <returns>object data values in json format</returns>

        override

        public string ToString()

        {

            return JsonConvert.SerializeObject(this, Formatting.None);

        }

    }

​

    /// <summary>

    /// WeatherData -  Data provided by weather service for one time unit of the 5 day forecast

    /// </summary>

    /// <remarks>

    /// Details on data structure available at http://openweathermap.org/forecast5

    /// For this exercise only extracting fields of interest.

    /// </remarks>

    public class ForecastUnit

    {

        /// <summary>

        /// date time of forecast

        /// </summary>

        public DateTime dt_txt { get; set; }

        /// <summary>

        /// Main portion of forecast, provides temperature

        /// </summary>

        public ForecastUnitMain main { get; set; }

        /// <summary>

        /// Weather portion of forecast, provides condition such as likelihood of rain, snow, etc

        /// </summary>

        public List<ForecastUnitWeather> weather { get; set; }

        /// <summary>

        /// Format object for printing

        /// </summary>

        /// <returns>object data values in json format</returns>

        override

        public string ToString()

        {

            return JsonConvert.SerializeObject(this, Formatting.None);

        }

    }

​

    /// <summary>

    /// Temparature portion of forecast

    /// </summary>

    /// <remarks>

    /// Inner class for deserializing one time unit of the 5 day forecast

    /// Details on data structure available at http://openweathermap.org/forecast5

    /// For this exercise only extracting fields of interest.

    /// </remarks>

    public class ForecastUnitMain

    {

        public double temp { get; set; }

        /// <summary>

        /// Format object for printing

        /// </summary>

        /// <returns>object data values in json format</returns>

        override

        public string ToString()

        {

            return JsonConvert.SerializeObject(this, Formatting.None);

        }

    }

​

    /// <summary>

    /// Weather portion of forecast

    /// </summary>

    /// <remarks>

    /// Inner class for deserializing one time unit of the 5 day forecast

    /// Details on data structure available at http://openweathermap.org/forecast5

    /// For this exercise only extracting fields of interest.

    /// </remarks>

    public class ForecastUnitWeather

    {

        public int id { get; set; }

        public string main { get; set; }

        /// <summary>

        /// Format object for printing

        /// </summary>

        /// <returns>object data values in json format</returns>

        override

        public string ToString()

        {

            return JsonConvert.SerializeObject(this, Formatting.None);

        }

    }

​

​

    #endregion Model Classes

    #region Utilities

    /// <summary>

    /// Custom exception associated with acquiring forecasts

    /// </summary>

    [Serializable]

    public class ForecastException : Exception

    {

        /// <summary>

        ///  Url attempted 

        /// </summary>

        public string RequestUrl { get; set; }

        public ForecastException()

        {

        }

​

        public ForecastException(string message)

        : base(message)

        {

        }

​

        public ForecastException(string message, Exception inner)

        : base(message, inner)

        {

        }

​

        public ForecastException(string message, Exception inner, string url)

        : base(message, inner)

        {

            RequestUrl = url;

        }

​

​

        /// <summary>

        /// Override Message to include custom properties: Url

        /// </summary>

        public override String Message

        {

            get

            {

                return base.Message + String.Format(", Url={0}", RequestUrl);

            }

        }

    }

    #endregion Utilities

​

}

​