DCU - Development Application Test | C# Online Compiler

DCU - Development Application Test by Michael Prado

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;
using DCU.ADT.Business;
using DCU.ADT.Common;
using DCU.ADT.Domain.Entities;
using DCU.ADT.Domain.Enums;
using DCU.ADT.Domain.Exceptions;
using DCU.ADT.Domain.Interfaces;
using DCU.ADT.Domain.ViewModels;
using GoogleMapsApi;
using GoogleMapsApi.Entities.Common;
using GoogleMapsApi.Entities.Geocoding.Request;
using GoogleMapsApi.Entities.Geocoding.Response;
using WeatherNet;
using WeatherNet.Clients;


// Just a overview what this application does:
// 
// 1 - Gets a list of cities from the GetCities() method.
// 2 - Passes this city list to the GetForecasts that will, in parallel:
// 2.1 - Use a Google Nuget Package to geocode City + State and return the center of the city
// 2.2 - In case the first call doesn't return a PostCode, it will Geocode again to set the CenterPostalCode of the city (required to user output)
// 2.3 - If no error happens, it will pass each city to the OpenForecastConsumer (that also uses a Nuget Package)
//       to get the next X days forecast. Application is set to 5.
// 3 - Once it gets all the forecasts back, it will print the results
// 
// Concepts and techniques used:
// 1 - Separation of concerns
// 2 - Dependency Injection
// 3 - Project/Solution in layers (check the #regions)
// 4 - Parallelism
// 5 - Custom Exception and Exception handling 
// 6 - Interfaces
// 7 - LINQ
// 
// Observations: 
// 
// 0 - The only reason I'm using google maps is because accuracy in OpenWeatherMap is only good working with Geocode (lat/long). 
//     Please check this link: https://openweathermap.desk.com/customer/portal/questions/16829365-state-is-missing-from-the-location-information-only-shows-city-this-is-critical-for-us-clients
//     Also, when passing Marlborough's zipcode, it was returning Worcester. (http://api.openweathermap.org/data/2.5/forecast?zip=01752&appid=7a38c16b76f67e9b53ee25b19fff4854)
// 1 - Fiddle only allows Roslym if you don't use Nuget. I chose to use Nuget and therefore I wasn't able to use some c#6 features
// 2 - I assumed the idea was not to have a very long code but one that works in a objective way. That's why I chose to use Nuget 
//     instead of building all the classes and objects to consume Google Maps and OpenWeatherMap's API
// 3 - I tried to play with colors but Fiddle doesn't allow that
// 4 - Some keys are in the code just because there is no .Config file in Fiddle
// 5 - The different #regions I used was to symbolize the different projects I would have in a solution. I usually have the web/output, business, domain and data layers
// 6 - I didn't want to polute the output console so I didn't implement any logging system. However, I added comments where I would put them.
// 7 - It's taking about 4s to process 10 cities. It goes to half of that avoiding the second call to google to get the postalcode. 

namespace DCU.ADT.Application
{
    public class Program
    {
        public static void Main()
        {
            //Creating the list of cities
            var cities = GetCities();
            //Passing all cities to the method that will fill extra information and get the forecasts
            //Ideally, there would be a DI here to automaticly create these two instances
            //The parameter of how many days is also passed here so we can easily change it if necessary
            var cityForecasts = GetForecasts(cities, new GoogleMapsCityManager(), new OpenWeatherMap(), 5);
            //Print results with 2 decimal places
            PrintResults(cityForecasts, 2);
        }

        /// <summary>
        /// Return all cities to be processed
        /// </summary>
        /// <returns></returns>
        private static IEnumerable<City> GetCities()
        {
            return new List<City>()
            {
                new City("Marlboro", EStateCodes.MA, 1),
                new City("San Diego", EStateCodes.CA, 2),
                new City("Cheyenne", EStateCodes.NY, 3),
                new City("Anchorage", EStateCodes.AK, 4),
                new City("Austin", EStateCodes.TX, 5),
                new City("Orlando", EStateCodes.FL, 6),
                new City("Seattle", EStateCodes.WA, 7),
                new City("Cleveland", EStateCodes.OH, 8),
                new City("Portland", EStateCodes.ME, 9),
                new City("Honolulu", EStateCodes.HI, 10)
            };
        }

        /// <summary>
        /// Processes each city getting its extra info (Lat/Long and ZipCode) and also
        /// fills the fore
        /// </summary>
        /// <param name="cities"></param>
        /// <param name="cityManager"></param>
        /// <param name="forecastConsumer"></param>
        /// <param name="numberOfDays"></param>
        /// <returns></returns>
        private static IEnumerable<CityForecast> GetForecasts(IEnumerable<City> cities, ICityManager cityManager, IForecastConsumer forecastConsumer, int numberOfDays)
        {
            var cityForecasts = new List<CityForecast>();
            //In parallel, let's process all cities
            Parallel.ForEach(cities, city =>
            {
                try
                {
                    var foreCastItem = new CityForecast { City = city };
                    //These two methods could be rewritten using async
                    //The only problem is that the packages being used don't provide that
                    cityManager.FillCityExtraInfo(city);
                    foreCastItem.Forecasts = forecastConsumer.GetForecast(city, numberOfDays);
                    //Adding the forecasts for this particular city
                    cityForecasts.Add(foreCastItem);
                }
                catch (BusinessException b)
                {
                    cityForecasts.Add(new CityForecast { City = city, ErrorMessage = b.Message });
                }
                catch (Exception)
                {
                    //Log.Error(e); //In case we want to log this somewhere...
                    cityForecasts.Add(new CityForecast
                    {
                        City = city,
                        ErrorMessage = "General error when getting city's info"
                    });
                }
            });

            return cityForecasts;
        }

        /// <summary>
        /// Outputs cities and their forecasts
        /// </summary>
        /// <param name="cities"></param>
        /// <param name="decimalPlaces"></param>
        private static void PrintResults(IEnumerable<CityForecast> cities, int decimalPlaces)
        {

            Console.WriteLine();
            foreach (var cityForecast in cities.OrderBy(c => c.City.Position))
            {
                Console.WriteLine("___________________________");
                //Console.WriteLine($"{cityForecast.City.Name}, {cityForecast.City.StateCode} ({cityForecast.City.CenterPostalCode})"); //Interpolation doesn't work in dotnetFiddle
                Console.WriteLine(cityForecast.City.Name + ", " + cityForecast.City.StateCode + "  (" + cityForecast.City.CenterPostalCode + ")");
                Console.WriteLine();
                if (cityForecast.ErrorMessage != null || cityForecast.Forecasts == null)
                {
                    //Console.ForegroundColor = ConsoleColor.Red; //Fiddle
                    Console.WriteLine(cityForecast.ErrorMessage ?? "General error");
                    //Console.ResetColor(); //Fiddle
                }
                else
                {
                    Console.WriteLine("Date                 Temp(F)     Temp(C)");
                    foreach (var weatherInfo in cityForecast.Forecasts)
                    {
                        //Console.WriteLine($"{weatherInfo.Date:d}{(weatherInfo.ChangeOfPrecipitation ? "*" : "")} {weatherInfo.GetTemperature()} {weatherInfo.GetTemperature(ETemperatureType.Celsius)}"); //Doesn't work on Fiddle
                        Console.WriteLine(weatherInfo.Date.ToString("dd/MM/yyyy") + (weatherInfo.ChanceOfPrecipitation ? " *" : "  ") + "         " + string.Format("{0:N2}", weatherInfo.GetTemperature(decimalPlaces)) + "       " + string.Format("{0:N2}", weatherInfo.GetTemperature(decimalPlaces, ETemperatureType.Celsius)));
                    }
                }
                Console.WriteLine();
                Console.WriteLine();
            }
            Console.WriteLine("* When some precipitation is expected");
        }
    }
}

namespace DCU.ADT.Domain
{
    namespace ViewModels
    {
        /// <summary>
        /// A class that joins a City and its forecast. If a error happened while getting info, ErrorMessage will be filled
        /// </summary>
        public class CityForecast
        {
            public City City { get; set; }
            public List<WeatherInfo> Forecasts { get; set; }

            /// <summary>
            /// Shows if there was any error processing a particular city
            /// </summary>
            public string ErrorMessage { get; set; }
        }
    }
    namespace Entities
    {
        /// <summary>
        /// Class to represent each city
        /// </summary>
        public class City
        {
            private readonly string _name;
            private readonly EStateCodes _state;

            /// <summary>
            /// A city only exists if a name and valid state is provided
            /// </summary>
            /// <param name="cityName"></param>
            /// <param name="stateCode"></param>
            /// <param name="pos"></param>
            public City(string cityName, EStateCodes stateCode, int pos)
            {
                _name = cityName;
                _state = stateCode;
            }
            /// <summary>
            /// Just to sort the output correctly
            /// </summary>
            public int Position { get; set; }
            /// <summary>
            /// Name of the city
            /// </summary>
            public string Name { get { return _name; } } //Had to keep this one because Fiddle does not accept auto properties yet
            /// <summary>
            /// State where city is located
            /// </summary>
            public EStateCodes StateCode { get { return _state; } } //Had to keep this one because Fiddle does not accept auto properties yet
            /// <summary>
            /// List of postal codes
            /// </summary>
            public string CenterPostalCode { get; set; }
            /// <summary>
            /// Latitude of the center of the city
            /// </summary>
            public double? CenterLatitude { get; set; }
            /// <summary>
            /// Longitude of the center of the city
            /// </summary>
            public double? CenterLongitude { get; set; }
        }

        /// <summary>
        /// This class represents 
        /// </summary>
        public class WeatherInfo
        {
            private double? _temperature;
            private ETemperatureType _tempType;
            private readonly DateTime _date;

            /// <summary>
            /// Constructor receiving necessary information to initiate the object
            /// </summary>
            /// <param name="date"></param>
            public WeatherInfo(DateTime date)
            {
                _date = date;
            }

            public void SetTemperature(double temperature, ETemperatureType tempType)
            {
                _temperature = temperature;
                _tempType = tempType;
            }

            /// <summary>
            /// The day this info represents
            /// </summary>
            public DateTime Date { get { return _date; } } //Fiddle... :-/
                                                           /// <summary>
                                                           /// If there is chance of precipitation
                                                           /// </summary>
            public bool ChanceOfPrecipitation { get; set; } //Fiddle... :-/
                                                            /// <summary>
                                                            /// Returns the expected temperature on the particular Date. Defaults to Fahrenheit.
                                                            /// </summary>
                                                            /// <param name="decimalPlaces"></param>
                                                            /// <param name="tempType"></param>
                                                            /// <returns></returns>
            public double? GetTemperature(int decimalPlaces, ETemperatureType tempType = ETemperatureType.Fahrenheit)
                                                            {
                if (_temperature == null) return null;
                //Easier to read the code this way
                if (tempType == _tempType) return Math.Round(_temperature.Value, 2);
                return Math.Round(tempType == ETemperatureType.Celsius ? ConvertTemp.ConvertFahrenheitToCelsius(_temperature.Value) : ConvertTemp.ConvertCelsiusToFahrenheit(_temperature.Value), 2);
            }
        }
    }
    namespace Enums
    {
        /// <summary>
        /// Defines the two different temperature measurements known
        /// </summary>
        public enum ETemperatureType
        {
            Celsius,
            Fahrenheit
        }
        /// <summary>
        /// Defines all US state codes
        /// </summary>
        public enum EStateCodes
        {
            AL, AK, AS, AZ, AR, CA, CO, CT, DE, DC, FM, FL, GA, GU, HI, ID, IL, IN, IA, KS, KY, LA, ME, MH, MD, MA,
            MI, MN, MS, MO, MT, NE, NV, NH, NJ, NM, NY, NC, ND, MP, OH, OK, OR, PW, PA, PR, RI, SC, SD, TN, TX, UT,
            VT, VI, VA, WA, WV, WI, WY
        }
    }
    namespace Interfaces
    {
        /// <summary>
        /// Interface responsible for handling cities operations
        /// </summary>
        public interface ICityManager
        {
            /// <summary>
            /// Defines a method to collect and fill city extra information like lat/long and zipcode
            /// </summary>
            /// <param name="city"></param>
            void FillCityExtraInfo(City city);
        }
        /// <summary>
        /// Defines methods to get weather information
        /// </summary>
        public interface IForecastConsumer
        {
            List<WeatherInfo> GetForecast(City city, int days);
        }
    }
    namespace Exceptions
    {
        /// <inheritdoc />
        /// <summary>
        /// Specific exception class for when we want to return messages to the user
        /// </summary>
        public class BusinessException : Exception
        {
            public BusinessException(string message) : base(message) { }
        }
    }
}
namespace DCU.ADT.Business
{
    /// <summary>
    /// To get some extra required information of each city, I implemented a class that will 
    /// use Google Maps to get the center lat/long and also the zipcodes
    /// Center Lat/Long is necessary because OpenWeather only works accurately when we procive geometry
    /// Zipcodes are necessary to show to the user
    /// </summary>
    public class GoogleMapsCityManager : ICityManager
    {
        /// <summary>
        /// This would definately be in a .config file. dotnetfiddle does not have it so I put it here.
        /// </summary>
        private readonly string googleMapsKey = "AIzaSyCTgrnIKGYri2D9_lCn7CAF6v3F6G6EwuU";

        public void FillCityExtraInfo(City city)
        {
            //Creating the request parameter to request the location from Google
            var requestCenterLatLong = new GeocodingRequest
            {
                ApiKey = googleMapsKey,
                //Address = $"{city.Name}, {city.StateCode.ToString()}" //Does not work on Fiddle
                Address = city.Name + ", " + city.StateCode
            };

            try
            {
                //Requesting information
                var resultCenterLatLong = GoogleMaps.Geocode.Query(requestCenterLatLong);
                if (resultCenterLatLong == null || resultCenterLatLong.Status != Status.OK) throw new BusinessException("Error consuming Google API.");
                if (!resultCenterLatLong.Results.Any()) throw new BusinessException("City not found");
                if (resultCenterLatLong.Results.First().Geometry == null || resultCenterLatLong.Results.First().Geometry.Location == null) throw new BusinessException("Geometry information not found");
                //Setting lat/long
                city.CenterLatitude = resultCenterLatLong.Results.First().Geometry.Location.Latitude;
                city.CenterLongitude = resultCenterLatLong.Results.First().Geometry.Location.Longitude;

                //On the same call, sometimes, we also receive the zipcode. Not for Marlborough though.
                if (resultCenterLatLong.Results.First().AddressComponents.All(ad => ad.ShortName != "postal_code"))
                {
                    var postalCodeRequest = new GeocodingRequest()
                    {
                        ApiKey = googleMapsKey,
                        Location = new Location(city.CenterLatitude.Value, city.CenterLongitude.Value)
                    };
                    var postalCodeResults = GoogleMaps.Geocode.Query(postalCodeRequest);
                    if (postalCodeResults.Status == Status.OK && postalCodeResults.Results.Any() && postalCodeResults.Results.First().AddressComponents != null)
                    {
                        var components = postalCodeResults.Results.First().AddressComponents;
                        var firstPostalCode = components.FirstOrDefault(ac => ac.Types != null && ac.Types.Any() && ac.Types.First() == "postal_code");
                        city.CenterPostalCode = firstPostalCode == null ? null : firstPostalCode.ShortName;
                    }
                }
                else
                {
                    //We got a zipcode in the first request
                    city.CenterPostalCode = resultCenterLatLong.Results.First().AddressComponents.First(ad => ad.ShortName == "postal_code").ShortName;
                }
            }
            catch
            {
                //We could use any logging tool (like log4net) to save the exception
                //In this exercise, I'm showing the user error message of each city when rendering the info
                //Log.Error(e);
                throw new BusinessException("There was a problem finding this city coordinates.");
            }
        }
    }

    /// <summary>
    /// This class connects to OpenWeatherMap.Org to get a city forecast
    /// </summary>
    public class OpenWeatherMap : IForecastConsumer
    {
        //Just like Google's class, this would be in an App.Config/Web.Config
        private const string appId = "7a38c16b76f67e9b53ee25b19fff4854";

        /// <summary>
        /// This method uses a Nuget Package to get weather information
        /// 
        /// Dear code analyzer: I could, of course, write a API consumer class implementing a HttpClient object,...
        /// ...POST (async) to the URL and use generics to transform the return JSON into a domain object that would have the same properties structure...
        /// ...but why reinvent the wheel, right ?
        /// 
        /// So I chose to use a Nuget package that does all that for me. Please give me a chance to implement in
        /// a different way if necessary. 
        /// 
        /// 
        /// 
        /// </summary>
        /// <param name="city"></param>
        /// <param name="days"></param>
        public List<WeatherInfo> GetForecast(City city, int days)
        {
            ClientSettings.ApiKey = appId;
            if (!(city.CenterLatitude.HasValue && city.CenterLongitude.HasValue)) return null;
            try
            {
                var cityForecastInfo = FiveDaysForecast.GetByCoordinates(city.CenterLatitude.Value, city.CenterLongitude.Value, "en", "imperial");
                if (!cityForecastInfo.Success || cityForecastInfo.Items == null || cityForecastInfo.Items.Count == 0)
                    throw new BusinessException("Could not load forecast from OpenWeatherMap.");

                var results = new List<WeatherInfo>();
                var timeUtc = DateTime.UtcNow;
                var easternZone = TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time");
                var easternTime = TimeZoneInfo.ConvertTimeFromUtc(timeUtc, easternZone);
                //Adding the next following X days
                for (var i = 1; i <= days; i++)
                {
                    results.Add(new WeatherInfo(easternTime.Date.AddDays(i)));
                }

                //We need to return the average per day, but OpenWeather returns objects with a date range.
                //So just for this exercise, if FROM or TO are contained in a particular day, we consider it


                results = results.Select(r =>
                {
                    if (cityForecastInfo.Items.All(t => t.Date.Date != r.Date)) return r;
                    r.SetTemperature(cityForecastInfo
                        .Items
                        .Where(f => f.Date.Date == r.Date)
                        .Select(f => (f.TempMin + f.TempMax) / 2) //Average
                        .Average(), ETemperatureType.Fahrenheit);

                    r.ChanceOfPrecipitation = cityForecastInfo
                        .Items
                        .Any(f => f.Date.Date == r.Date && f.Title.IndexOf("rain", StringComparison.CurrentCultureIgnoreCase) >= 0);

                    return r;
                }).ToList();

                return results;
            }
            catch (Exception e)
            {
                //Log.Error(e);
                if (e is BusinessException) throw;
                throw new BusinessException("There was an error consuming OpenWeatherMap API");
            }
        }
    }
}
namespace DCU.ADT.Common
{
    /// <summary>
    /// Class just to convert between both types
    /// </summary>
    internal static class ConvertTemp
    {
        public static double ConvertCelsiusToFahrenheit(double c)
        {
            return ((9.0 / 5.0) * c) + 32;
        }

        public static double ConvertFahrenheitToCelsius(double f)
        {
            return (5.0 / 9.0) * (f - 32);
        }
    }
}

​x
 
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;
using DCU.ADT.Business;
using DCU.ADT.Common;
using DCU.ADT.Domain.Entities;
using DCU.ADT.Domain.Enums;
using DCU.ADT.Domain.Exceptions;
using DCU.ADT.Domain.Interfaces;
using DCU.ADT.Domain.ViewModels;
using GoogleMapsApi;
using GoogleMapsApi.Entities.Common;
using GoogleMapsApi.Entities.Geocoding.Request;
using GoogleMapsApi.Entities.Geocoding.Response;
using WeatherNet;
using WeatherNet.Clients;
​
​
// Just a overview what this application does:
// 
// 1 - Gets a list of cities from the GetCities() method.
// 2 - Passes this city list to the GetForecasts that will, in parallel:
// 2.1 - Use a Google Nuget Package to geocode City + State and return the center of the city
// 2.2 - In case the first call doesn't return a PostCode, it will Geocode again to set the CenterPostalCode of the city (required to user output)
// 2.3 - If no error happens, it will pass each city to the OpenForecastConsumer (that also uses a Nuget Package)
//       to get the next X days forecast. Application is set to 5.
// 3 - Once it gets all the forecasts back, it will print the results
// 
// Concepts and techniques used:
// 1 - Separation of concerns
// 2 - Dependency Injection
// 3 - Project/Solution in layers (check the #regions)
// 4 - Parallelism
// 5 - Custom Exception and Exception handling 
// 6 - Interfaces
// 7 - LINQ
// 
// Observations: 
// 
// 0 - The only reason I'm using google maps is because accuracy in OpenWeatherMap is only good working with Geocode (lat/long). 
//     Please check this link: https://openweathermap.desk.com/customer/portal/questions/16829365-state-is-missing-from-the-location-information-only-shows-city-this-is-critical-for-us-clients
//     Also, when passing Marlborough's zipcode, it was returning Worcester. (http://api.openweathermap.org/data/2.5/forecast?zip=01752&appid=7a38c16b76f67e9b53ee25b19fff4854)
// 1 - Fiddle only allows Roslym if you don't use Nuget. I chose to use Nuget and therefore I wasn't able to use some c#6 features
// 2 - I assumed the idea was not to have a very long code but one that works in a objective way. That's why I chose to use Nuget 
//     instead of building all the classes and objects to consume Google Maps and OpenWeatherMap's API
// 3 - I tried to play with colors but Fiddle doesn't allow that
// 4 - Some keys are in the code just because there is no .Config file in Fiddle
// 5 - The different #regions I used was to symbolize the different projects I would have in a solution. I usually have the web/output, business, domain and data layers
// 6 - I didn't want to polute the output console so I didn't implement any logging system. However, I added comments where I would put them.
// 7 - It's taking about 4s to process 10 cities. It goes to half of that avoiding the second call to google to get the postalcode. 
​
namespace DCU.ADT.Application
{
    public class Program
    {
        public static void Main()
        {
            //Creating the list of cities
            var cities = GetCities();
            //Passing all cities to the method that will fill extra information and get the forecasts
            //Ideally, there would be a DI here to automaticly create these two instances
            //The parameter of how many days is also passed here so we can easily change it if necessary
            var cityForecasts = GetForecasts(cities, new GoogleMapsCityManager(), new OpenWeatherMap(), 5);
            //Print results with 2 decimal places
            PrintResults(cityForecasts, 2);
        }
​
        /// <summary>
        /// Return all cities to be processed
        /// </summary>
        /// <returns></returns>
        private static IEnumerable<City> GetCities()
        {
            return new List<City>()
            {
                new City("Marlboro", EStateCodes.MA, 1),
                new City("San Diego", EStateCodes.CA, 2),
                new City("Cheyenne", EStateCodes.NY, 3),
                new City("Anchorage", EStateCodes.AK, 4),
                new City("Austin", EStateCodes.TX, 5),
                new City("Orlando", EStateCodes.FL, 6),
                new City("Seattle", EStateCodes.WA, 7),
                new City("Cleveland", EStateCodes.OH, 8),
                new City("Portland", EStateCodes.ME, 9),
                new City("Honolulu", EStateCodes.HI, 10)
            };
        }
​
        /// <summary>
        /// Processes each city getting its extra info (Lat/Long and ZipCode) and also
        /// fills the fore
        /// </summary>
        /// <param name="cities"></param>
        /// <param name="cityManager"></param>
        /// <param name="forecastConsumer"></param>
        /// <param name="numberOfDays"></param>
        /// <returns></returns>
        private static IEnumerable<CityForecast> GetForecasts(IEnumerable<City> cities, ICityManager cityManager, IForecastConsumer forecastConsumer, int numberOfDays)
        {
            var cityForecasts = new List<CityForecast>();
            //In parallel, let's process all cities
            Parallel.ForEach(cities, city =>
            {
                try
                {
                    var foreCastItem = new CityForecast { City = city };
                    //These two methods could be rewritten using async
                    //The only problem is that the packages being used don't provide that
                    cityManager.FillCityExtraInfo(city);
                    foreCastItem.Forecasts = forecastConsumer.GetForecast(city, numberOfDays);
                    //Adding the forecasts for this particular city
                    cityForecasts.Add(foreCastItem);
                }
                catch (BusinessException b)
                {
                    cityForecasts.Add(new CityForecast { City = city, ErrorMessage = b.Message });
                }
                catch (Exception)
                {
                    //Log.Error(e); //In case we want to log this somewhere...
                    cityForecasts.Add(new CityForecast
                    {
                        City = city,
                        ErrorMessage = "General error when getting city's info"
                    });
                }
            });
​
            return cityForecasts;
        }
​
        /// <summary>
        /// Outputs cities and their forecasts
        /// </summary>
        /// <param name="cities"></param>
        /// <param name="decimalPlaces"></param>
        private static void PrintResults(IEnumerable<CityForecast> cities, int decimalPlaces)
        {
​
            Console.WriteLine();
            foreach (var cityForecast in cities.OrderBy(c => c.City.Position))
            {
                Console.WriteLine("___________________________");
                //Console.WriteLine($"{cityForecast.City.Name}, {cityForecast.City.StateCode} ({cityForecast.City.CenterPostalCode})"); //Interpolation doesn't work in dotnetFiddle
                Console.WriteLine(cityForecast.City.Name + ", " + cityForecast.City.StateCode + "  (" + cityForecast.City.CenterPostalCode + ")");
                Console.WriteLine();
                if (cityForecast.ErrorMessage != null || cityForecast.Forecasts == null)
                {
                    //Console.ForegroundColor = ConsoleColor.Red; //Fiddle
                    Console.WriteLine(cityForecast.ErrorMessage ?? "General error");
                    //Console.ResetColor(); //Fiddle
                }
                else
                {
                    Console.WriteLine("Date                 Temp(F)     Temp(C)");
                    foreach (var weatherInfo in cityForecast.Forecasts)
                    {
                        //Console.WriteLine($"{weatherInfo.Date:d}{(weatherInfo.ChangeOfPrecipitation ? "*" : "")} {weatherInfo.GetTemperature()} {weatherInfo.GetTemperature(ETemperatureType.Celsius)}"); //Doesn't work on Fiddle
                        Console.WriteLine(weatherInfo.Date.ToString("dd/MM/yyyy") + (weatherInfo.ChanceOfPrecipitation ? " *" : "  ") + "         " + string.Format("{0:N2}", weatherInfo.GetTemperature(decimalPlaces)) + "       " + string.Format("{0:N2}", weatherInfo.GetTemperature(decimalPlaces, ETemperatureType.Celsius)));
                    }
                }
                Console.WriteLine();
                Console.WriteLine();
            }
            Console.WriteLine("* When some precipitation is expected");
        }
    }
}
​
namespace DCU.ADT.Domain
{
    namespace ViewModels
    {
        /// <summary>
        /// A class that joins a City and its forecast. If a error happened while getting info, ErrorMessage will be filled
        /// </summary>
        public class CityForecast
        {
            public City City { get; set; }
            public List<WeatherInfo> Forecasts { get; set; }
​
            /// <summary>
            /// Shows if there was any error processing a particular city
            /// </summary>
            public string ErrorMessage { get; set; }
        }
    }
    namespace Entities
    {
        /// <summary>
        /// Class to represent each city
        /// </summary>
        public class City
        {
            private readonly string _name;
            private readonly EStateCodes _state;
​
            /// <summary>
            /// A city only exists if a name and valid state is provided
            /// </summary>
            /// <param name="cityName"></param>
            /// <param name="stateCode"></param>
            /// <param name="pos"></param>
            public City(string cityName, EStateCodes stateCode, int pos)
            {
                _name = cityName;
                _state = stateCode;
            }
            /// <summary>
            /// Just to sort the output correctly
            /// </summary>
            public int Position { get; set; }
            /// <summary>
            /// Name of the city
            /// </summary>
            public string Name { get { return _name; } } //Had to keep this one because Fiddle does not accept auto properties yet
            /// <summary>
            /// State where city is located
            /// </summary>
            public EStateCodes StateCode { get { return _state; } } //Had to keep this one because Fiddle does not accept auto properties yet
            /// <summary>
            /// List of postal codes
            /// </summary>
            public string CenterPostalCode { get; set; }
            /// <summary>
            /// Latitude of the center of the city
            /// </summary>
            public double? CenterLatitude { get; set; }
            /// <summary>
            /// Longitude of the center of the city
            /// </summary>
            public double? CenterLongitude { get; set; }
        }
​
        /// <summary>
        /// This class represents 
        /// </summary>
        public class WeatherInfo
        {
            private double? _temperature;
            private ETemperatureType _tempType;
            private readonly DateTime _date;
​
            /// <summary>
            /// Constructor receiving necessary information to initiate the object
            /// </summary>
            /// <param name="date"></param>
            public WeatherInfo(DateTime date)
            {
                _date = date;
            }
​
            public void SetTemperature(double temperature, ETemperatureType tempType)
            {
                _temperature = temperature;
                _tempType = tempType;
            }
​
            /// <summary>
            /// The day this info represents
            /// </summary>
            public DateTime Date { get { return _date; } } //Fiddle... :-/
                                                           /// <summary>
                                                           /// If there is chance of precipitation
                                                           /// </summary>
            public bool ChanceOfPrecipitation { get; set; } //Fiddle... :-/
                                                            /// <summary>
                                                            /// Returns the expected temperature on the particular Date. Defaults to Fahrenheit.
                                                            /// </summary>
                                                            /// <param name="decimalPlaces"></param>
                                                            /// <param name="tempType"></param>
                                                            /// <returns></returns>
            public double? GetTemperature(int decimalPlaces, ETemperatureType tempType = ETemperatureType.Fahrenheit)
                                                            {
                if (_temperature == null) return null;
                //Easier to read the code this way
                if (tempType == _tempType) return Math.Round(_temperature.Value, 2);
                return Math.Round(tempType == ETemperatureType.Celsius ? ConvertTemp.ConvertFahrenheitToCelsius(_temperature.Value) : ConvertTemp.ConvertCelsiusToFahrenheit(_temperature.Value), 2);
            }
        }
    }
    namespace Enums
    {
        /// <summary>
        /// Defines the two different temperature measurements known
        /// </summary>
        public enum ETemperatureType
        {
            Celsius,
            Fahrenheit
        }
        /// <summary>
        /// Defines all US state codes
        /// </summary>
        public enum EStateCodes
        {
            AL, AK, AS, AZ, AR, CA, CO, CT, DE, DC, FM, FL, GA, GU, HI, ID, IL, IN, IA, KS, KY, LA, ME, MH, MD, MA,
            MI, MN, MS, MO, MT, NE, NV, NH, NJ, NM, NY, NC, ND, MP, OH, OK, OR, PW, PA, PR, RI, SC, SD, TN, TX, UT,
            VT, VI, VA, WA, WV, WI, WY
        }
    }
    namespace Interfaces
    {
        /// <summary>
        /// Interface responsible for handling cities operations
        /// </summary>
        public interface ICityManager
        {
            /// <summary>
            /// Defines a method to collect and fill city extra information like lat/long and zipcode
            /// </summary>
            /// <param name="city"></param>
            void FillCityExtraInfo(City city);
        }
        /// <summary>
        /// Defines methods to get weather information
        /// </summary>
        public interface IForecastConsumer
        {
            List<WeatherInfo> GetForecast(City city, int days);
        }
    }
    namespace Exceptions
    {
        /// <inheritdoc />
        /// <summary>
        /// Specific exception class for when we want to return messages to the user
        /// </summary>
        public class BusinessException : Exception
        {
            public BusinessException(string message) : base(message) { }
        }
    }
}
namespace DCU.ADT.Business
{
    /// <summary>
    /// To get some extra required information of each city, I implemented a class that will 
    /// use Google Maps to get the center lat/long and also the zipcodes
    /// Center Lat/Long is necessary because OpenWeather only works accurately when we procive geometry
    /// Zipcodes are necessary to show to the user
    /// </summary>
    public class GoogleMapsCityManager : ICityManager
    {
        /// <summary>
        /// This would definately be in a .config file. dotnetfiddle does not have it so I put it here.
        /// </summary>
        private readonly string googleMapsKey = "AIzaSyCTgrnIKGYri2D9_lCn7CAF6v3F6G6EwuU";
​
        public void FillCityExtraInfo(City city)
        {
            //Creating the request parameter to request the location from Google
            var requestCenterLatLong = new GeocodingRequest
            {
                ApiKey = googleMapsKey,
                //Address = $"{city.Name}, {city.StateCode.ToString()}" //Does not work on Fiddle
                Address = city.Name + ", " + city.StateCode
            };
​
            try
            {
                //Requesting information
                var resultCenterLatLong = GoogleMaps.Geocode.Query(requestCenterLatLong);
                if (resultCenterLatLong == null || resultCenterLatLong.Status != Status.OK) throw new BusinessException("Error consuming Google API.");
                if (!resultCenterLatLong.Results.Any()) throw new BusinessException("City not found");
                if (resultCenterLatLong.Results.First().Geometry == null || resultCenterLatLong.Results.First().Geometry.Location == null) throw new BusinessException("Geometry information not found");
                //Setting lat/long
                city.CenterLatitude = resultCenterLatLong.Results.First().Geometry.Location.Latitude;
                city.CenterLongitude = resultCenterLatLong.Results.First().Geometry.Location.Longitude;
​
                //On the same call, sometimes, we also receive the zipcode. Not for Marlborough though.
                if (resultCenterLatLong.Results.First().AddressComponents.All(ad => ad.ShortName != "postal_code"))
                {
                    var postalCodeRequest = new GeocodingRequest()
                    {
                        ApiKey = googleMapsKey,
                        Location = new Location(city.CenterLatitude.Value, city.CenterLongitude.Value)
                    };
                    var postalCodeResults = GoogleMaps.Geocode.Query(postalCodeRequest);
                    if (postalCodeResults.Status == Status.OK && postalCodeResults.Results.Any() && postalCodeResults.Results.First().AddressComponents != null)
                    {
                        var components = postalCodeResults.Results.First().AddressComponents;
                        var firstPostalCode = components.FirstOrDefault(ac => ac.Types != null && ac.Types.Any() && ac.Types.First() == "postal_code");
                        city.CenterPostalCode = firstPostalCode == null ? null : firstPostalCode.ShortName;
                    }
                }
                else
                {
                    //We got a zipcode in the first request
                    city.CenterPostalCode = resultCenterLatLong.Results.First().AddressComponents.First(ad => ad.ShortName == "postal_code").ShortName;
                }
            }
            catch
            {
                //We could use any logging tool (like log4net) to save the exception
                //In this exercise, I'm showing the user error message of each city when rendering the info
                //Log.Error(e);
                throw new BusinessException("There was a problem finding this city coordinates.");
            }
        }
    }
​
    /// <summary>
    /// This class connects to OpenWeatherMap.Org to get a city forecast
    /// </summary>
    public class OpenWeatherMap : IForecastConsumer
    {
        //Just like Google's class, this would be in an App.Config/Web.Config
        private const string appId = "7a38c16b76f67e9b53ee25b19fff4854";
​
        /// <summary>
        /// This method uses a Nuget Package to get weather information
        /// 
        /// Dear code analyzer: I could, of course, write a API consumer class implementing a HttpClient object,...
        /// ...POST (async) to the URL and use generics to transform the return JSON into a domain object that would have the same properties structure...
        /// ...but why reinvent the wheel, right ?
        /// 
        /// So I chose to use a Nuget package that does all that for me. Please give me a chance to implement in
        /// a different way if necessary. 
        /// 
        /// 
        /// 
        /// </summary>
        /// <param name="city"></param>
        /// <param name="days"></param>
        public List<WeatherInfo> GetForecast(City city, int days)
        {
            ClientSettings.ApiKey = appId;
            if (!(city.CenterLatitude.HasValue && city.CenterLongitude.HasValue)) return null;
            try
            {
                var cityForecastInfo = FiveDaysForecast.GetByCoordinates(city.CenterLatitude.Value, city.CenterLongitude.Value, "en", "imperial");
                if (!cityForecastInfo.Success || cityForecastInfo.Items == null || cityForecastInfo.Items.Count == 0)
                    throw new BusinessException("Could not load forecast from OpenWeatherMap.");
​
                var results = new List<WeatherInfo>();
                var timeUtc = DateTime.UtcNow;
                var easternZone = TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time");
                var easternTime = TimeZoneInfo.ConvertTimeFromUtc(timeUtc, easternZone);
                //Adding the next following X days
                for (var i = 1; i <= days; i++)
                {
                    results.Add(new WeatherInfo(easternTime.Date.AddDays(i)));
                }
​
                //We need to return the average per day, but OpenWeather returns objects with a date range.
                //So just for this exercise, if FROM or TO are contained in a particular day, we consider it
​
​
                results = results.Select(r =>
                {
                    if (cityForecastInfo.Items.All(t => t.Date.Date != r.Date)) return r;
                    r.SetTemperature(cityForecastInfo
                        .Items
                        .Where(f => f.Date.Date == r.Date)
                        .Select(f => (f.TempMin + f.TempMax) / 2) //Average
                        .Average(), ETemperatureType.Fahrenheit);
​
                    r.ChanceOfPrecipitation = cityForecastInfo
                        .Items
                        .Any(f => f.Date.Date == r.Date && f.Title.IndexOf("rain", StringComparison.CurrentCultureIgnoreCase) >= 0);
​
                    return r;
                }).ToList();
​
                return results;
            }
            catch (Exception e)
            {
                //Log.Error(e);
                if (e is BusinessException) throw;
                throw new BusinessException("There was an error consuming OpenWeatherMap API");
            }
        }
    }
}
namespace DCU.ADT.Common
{
    /// <summary>
    /// Class just to convert between both types
    /// </summary>
    internal static class ConvertTemp
    {
        public static double ConvertCelsiusToFahrenheit(double c)
        {
            return ((9.0 / 5.0) * c) + 32;
        }
​
        public static double ConvertFahrenheitToCelsius(double f)
        {
            return (5.0 / 9.0) * (f - 32);
        }
    }
}

View IL Code