using Newtonsoft.Json;

using Newtonsoft.Json.Converters;

using System;

using System.Collections.Generic;

​

namespace ConductiveDemo

{

    public class Program

    {

        public static void Main()

        {

            // Please email conductiv-eng@outlook.com if you have any questions.

            // When complete, please send your name and the URL of your "Share Link" (.NET Fiddle menu item Share > Share Link) to conductiv-eng@outlook.com. Thank you!

            // Note: usings directives include typical libraries needed (feel free to add more if needed), also NuGet Package Newtonsoft.Json is included

​

            // Given input json for three organizations

            // Return list of all years in date range:

            // 1) Calendar years

            // 2) Fiscal years

​

            var inputJSON = @"

            [

                {

                    orgId: 1,

                    startDate: '2018-1-01T00:00:00',

                    endDate: '2020-8-29T00:00:00',

                    fiscalYearEnd: 12

                },

                {

                    orgId: 2,

                    startDate: '2018-1-01T00:00:00',

                    endDate: '2020-8-29T00:00:00',

                    fiscalYearEnd: 6

                },

                {

                    orgId: 3,

                    startDate: '2018-9-01T00:00:00',

                    endDate: '2020-8-29T00:00:00',

                    fiscalYearEnd: 8

                }

            ]";

​

            //Correct Output

            /*

            [

                {

                    "orgId": 1,

                    "calendarYears": [2018,2019,2020],

                    "fiscalYears": [2018,2019,2020]

                },

                {

                    "orgId": 2,

                    "calendarYears": [2018,2019,2020],

                    "fiscalYears": [2018,2019,2020,2021]

                },

                {

                    "orgId": 3,

                    "calendarYears": [2018,2019,2020],

                    "fiscalYears": [2019,2020]

                }

            ]

            */

​

            // TODO Tasks

            // 1) Create classes to deserialize JSON (use JSON.NET)

            // 2) Perform calculation from start/end dates to get range of calendar and fiscal years

            // 3) Output JSON to match correct output above

​

            try

            {

                var organizationData = ConvertData<List<OrganizationData>>(inputJSON);

                var results = new List<OrganizationResult>();

​

                foreach (var item in organizationData)

                {

                    results.Add(ProcessOrganization(item));

                }

​

                //Format to make readable in the console window

                var returnJson = JsonConvert.SerializeObject(results, Formatting.Indented);

​

                //Get out

                Console.WriteLine(returnJson);

            }

            catch (Exception ex)

            {

                //Boom

                Console.WriteLine(ex.Message.ToString());

            }

            finally

            {

                //And that was all she wrote.

                //Fiddle does not support read.

                //Console.WriteLine("Press [Any] key to end.");

                //Console.Read();

            }

        }

​

        /// <summary>

        /// Method is overkill for demo, demonstrating use of generics. I use this method is API frameworks

        /// </summary>

        private static T ConvertData<T>(string json, JsonConverter converter = null)

        {

            if (string.IsNullOrWhiteSpace(json))

                return default(T);

​

            if (converter == null)

                return JsonConvert.DeserializeObject<T>(json, new IsoDateTimeConverter());

            else

                return JsonConvert.DeserializeObject<T>(json, converter);

        }

​

        private static OrganizationResult ProcessOrganization(OrganizationData organizationData)

        {

            //Results

            var results = new OrganizationResult()

            {

                OrganizationId = organizationData.OrganizationId

            };

​

            //CalendarYears

            results.CalendarYears.AddRange(BuildYears(organizationData.StartDate.Year, organizationData.EndDate.Year));

​

            //Get the start and end Fiscal Years

            var startYear = organizationData.StartDate.ToFinancialYear(organizationData.FiscalYearEnd);

            var endYear = organizationData.EndDate.ToFinancialYear(organizationData.FiscalYearEnd);

​

            //FiscalYears

            results.FiscalYears.AddRange(BuildYears(startYear, endYear));

​

            //Gata

            return results;

        }

​

        private static IList<int> BuildYears(int startYear, int endYear)

        {

            //Results

            var results = new List<int>();

​

            //Loop count for years

            int years = (endYear - startYear) + 1;

​

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

            {

                //Note: The first pass index = 0 to include the start year in the loop

                results.Add(startYear + i);

            }

​

            return results;

        }

​

    }

​

    public class OrganizationData

    {

        [JsonProperty("orgId")]

        public int OrganizationId { get; set; }

​

        [JsonProperty("startDate")]

        public DateTime StartDate { get; set; }

​

        [JsonProperty("endDate")]

        public DateTime EndDate { get; set; }

​

        [JsonProperty("fiscalYearEnd")]

        public int FiscalYearEnd { get; set; }

    }

​

    public class OrganizationResult

    {

        public OrganizationResult()

        {

            CalendarYears = new List<int>();

            FiscalYears = new List<int>();

        }

​

        [JsonProperty("orgId")]

        public int OrganizationId { get; set; }

​

        [JsonProperty("calendarYears")]

        public IList<int> CalendarYears { get; set; }

​

        [JsonProperty("fiscalYears")]

        public IList<int> FiscalYears { get; set; }

    }

​

    public static class DateTimeExtensions

    {

        public static int ToFinancialYear(this DateTime dateTime, int yearEndMonth)

        {

            return (dateTime.Month > yearEndMonth ? dateTime.Year + 1 : dateTime.Year);

        }

    }

​

    public static class CollectionExtensions

    {

        public static void AddRange<T>(this IList<T> values, IList<T> collection)

        {

            if (values == null)

                return;

​

            if (!values.IsReadOnly && collection != null)

            {

                foreach (T t in collection)

                {

                    values.Add(t);

                }

            }

        }

    }

}

​