//  IMPORTANT: 

//

//  When you are done, please click on the Share button above and reply to the assessment email with your new link 

//  so that we can access your code and evaluate it.

//

//  You have 60 minutes to complete as many tests as possible. We understand that it may not be possible to complete

//  all seven tests within the allocated time, but just do your best to complete as many as you can correctly.

// 

//  You MUST email the new link to Mangan, Inc. within the 60 minute timeframe. 

//  Please only override the methods that are presently throwing the Not Implemented exception. 

//  Do NOT edit the testX methods for Tests 1, 2, and 3 please.

​

​

using NUnit.Framework;

​

using System;

​

using System.Collections.Generic;

​

using System.Linq;

​

​

public class Program

{

    public enum ORDER_STATUS 

    {

        REJECTED, // the driver has indicated that they will NOT handle the order

        CONFIRMED, // the driver has indicated that they will pickup & deliver the order

        PICKED_UP, // the driver has picked up the order (ideally within the specified arrival window)

        DROPPED_OFF, // the driver has dropped off the order (ideally within the specified delivery window)

        DISPATCHED, // the order has been dispatched to a driver (the driver will then confirm or reject the order)

    }

    class Order 

    {

        public int id {get; set;} // a unique identifier for the order

        ORDER_STATUS status {get; set;} // the current status of the order

        public DateTime? dispatchedTime {get; set;} // the time that the order was dispatched to the driver

        public DateTime? confirmedTime {get; set; } // the time that the driver confirmed the order

        public DateTime? rejectedTime {get; set; } // the time that the driver rejected the order

        public DateTime? arrivalTime {get; set; } // the time that the driver arrived to pick up the order (ideally within the arrival window)

        public DateTime? deliveryTime {get; set;} // the time that the driver dropped off the order (ideally within the delivery window)

        public DateTime targetArrivalStart {get; set;} // represents the start of the allowed 'arrival' window

        public DateTime targetArrivalEnd {get; set;} // represents the end of the allowed 'arrival' window

        public DateTime targetDeliveryStart {get; set;} // represents the start of the allowed 'delivery' window

        public DateTime targetDeliveryEnd {get; set; } // represents the end of the allowed 'delivery' window

        public decimal baseRate {get; set;} // the minimum driver pay

        public DateTime? createdWhen {get; set;} // when the order was created

        public string createdBy {get; set;} // who created the order

    }   

    public static void Main()

    {

        test1();

        test2();

        test3();

        test4();

        test5();

        test6();

        test7();

    }

    public static void test1()

    {

        // ***************************************************************************************************************

        //

        //  Test #1

        //

        //  Write code in the method StringParser that will take the given input string and convert it to a pseudo-XML string, 

        //  as shown in the expectedOutput variable.

        //  The returned string must pass the Asserts at the end of the test method.

        //

        //

        // ***************************************************************************************************************

        string input = "Ellen*Ripley*1234 Speedway*Tucson~Dwayne*Hicks*4567 Main*Houston~Carter*Burke*9876 Broadway*Las Vegas";

        string expectedOutput = "<1><1-1>Ellen</1-1><1-2>Ripley</1-2><1-3>1234 Speedway</1-3><1-4>Tucson</1-4></1>" +

                                "<2><2-1>Dwayne</2-1><2-2>Hicks</2-2><2-3>4567 Main</2-3><2-4>Houston</2-4></2>" +

                                "<3><3-1>Carter</3-1><3-2>Burke</3-2><3-3>9876 Broadway</3-3><3-4>Las Vegas</3-4></3>";

​

        string output = StringParser(input);

​

        Assert.AreEqual(expectedOutput, output);

    }

​

    private static string StringParser(string input)

    {

        var parts = input.Split('~');

        var result = "";

​

        for (int i = 0; i < parts.Length; i++)

        {

            var details = parts[i].Split('*');

            result += $"<{i + 1}>";

            for (int j = 0; j < details.Length; j++)

            {

                result += $"<{i + 1}-{j + 1}>{details[j]}</{i + 1}-{j + 1}>";

            }

            result += $"</{i + 1}>";

        }

​

        return result;

    }

    public static void test2()

    {

        // ***************************************************************************************************************

        //

        //  Test #2

        //

        //  Code the divisor function to take an input variable and divide it by the denominator variable until it is at or

        //  below the value of limit, then return the new value.

        //

        //  The returned double must pass the Asserts at the end of the test method.

        //

        // ***************************************************************************************************************

       Assert.AreEqual(77, divisor(1232, 4, 200));

        Assert.AreEqual(42.645454545454548d, divisor(234.55, 5.5, 171));

        Assert.AreEqual(111, divisor(333, 3, 111));

        Assert.AreEqual(20, divisor(20, 3, 33));

    }

​

    private static double divisor(double input, double denominator, double limit)

    {

        while (input > limit)

        {

            input /= denominator;

        }

        return input;

    }

    public static void test3()

    {

        // ***************************************************************************************************************

        //

        //  Test #3

        //

        //  Code the divisor function again, but this time use a recursive method to do so.

        //

        //  The returned double must pass the Asserts at the end of the test method.

        //

        // ***************************************************************************************************************

       Assert.AreEqual(77, divisorRecursive(1232, 4, 200));

        Assert.AreEqual(42.645454545454548d, divisorRecursive(234.55, 5.5, 171));

        Assert.AreEqual(111, divisorRecursive(333, 3, 111));

        Assert.AreEqual(20, divisorRecursive(20, 3, 33));

    }

​

    private static double divisorRecursive(double input, double denominator, double limit)

    {

        if (input <= limit) return input;

        return divisorRecursive(input / denominator, denominator, limit);

    }

    public static void test4()

{

    Dictionary<string, string> dictionary = new Dictionary<string, string>

    {

        { "name", "John" },

        { "age", "30" }

    };

​

    // Ran out of time to correct

    Assert.AreEqual("John", dictionary.GetValueOrNull("name"));  // should return "John"

    Assert.AreEqual(null, dictionary.GetValueOrNull("address"));  // should return null, since "address" doesn't exist

}

​

​

public static string GetValueOrNull(this Dictionary<string, string> dict, string key)

{

    return dict.ContainsKey(key) ? dict[key] : null;

}

        // ***************************************************************************************************************

        //

        //  Test #4

        //

        //  Write an extension method that will return the value of a dictionary entry if it is present, otherwise null

        //

        //  Please add Asserts to validate your solution

        //

        // ***************************************************************************************************************

​

    public static void test5() 

    {

         List<Order> orders = new List<Order>

    {

        new Order { id = 1, status = ORDER_STATUS.DROPPED_OFF, createdWhen = new DateTime(2024, 11, 1), deliveryTime = DateTime.Now, baseRate = 10m },

        new Order { id = 2, status = ORDER_STATUS.PICKED_UP, createdWhen = new DateTime(2024, 10, 20) },

        new Order { id = 3, status = ORDER_STATUS.DROPPED_OFF, createdWhen = new DateTime(2024, 11, 2), deliveryTime = DateTime.Now, baseRate = 20m }

    };

​

    var result = FindLastDeliveredOrderAfterFirstOfMonth(orders);

    Assert.AreEqual(3, result.id);  // Expected order with id = 3, because it was delivered after the 1st of November

}

​

public static Order FindLastDeliveredOrderAfterFirstOfMonth(List<Order> orders)

{

    return orders

        .Where(o => o.createdWhen.HasValue && o.createdWhen.Value.Day > 1 && o.status == ORDER_STATUS.DROPPED_OFF)

        .OrderByDescending(o => o.createdWhen)  

        .FirstOrDefault(); 

        // ***************************************************************************************************************

        //

        //  Test #5

        //

        //  Write a function that will accept a list of Orders (see class defintion at the top)

        //

        //  The function must return the last entry in the list that was created after the first of the month AND has been 

        //    delivered

        //

        //  Please add Asserts to validate your solution

        //

        // ***************************************************************************************************************

    }

    public static void test6() 

    {

        List<Order> orders = new List<Order>

    {

        new Order { id = 1, status = ORDER_STATUS.DROPPED_OFF, createdWhen = new DateTime(2024, 11, 1), deliveryTime = DateTime.Now, baseRate = 10m },

        new Order { id = 2, status = ORDER_STATUS.PICKED_UP, createdWhen = new DateTime(2024, 10, 20) },

        new Order { id = 3, status = ORDER_STATUS.DROPPED_OFF, createdWhen = new DateTime(2024, 11, 2), deliveryTime = DateTime.Now, baseRate = 20m }

    };

​

    var result = orders

        .Where(o => o.createdWhen.HasValue && o.createdWhen.Value.Day > 1 && o.status == ORDER_STATUS.DROPPED_OFF)  // Filter orders delivered after the 1st of the month

        .LastOrDefault(); 

​

    Assert.AreEqual(3, result.id); 

        // ***************************************************************************************************************

        //

        //  Test #6

        //

        //  Rewrite the implementation for test 5 in a new way (e.g. Linq, looping, etc)

        //

        //  Please add Asserts to validate your solution

        //

        // ***************************************************************************************************************

    }

    public static void test7()

    {

        var order = new Order

        {

            status = ORDER_STATUS.DROPPED_OFF,

            arrivalTime = DateTime.Now.AddMinutes(-10),

            deliveryTime = DateTime.Now.AddMinutes(-5),

            baseRate = 100m,

            targetArrivalStart = DateTime.Now.AddMinutes(-20),

            targetArrivalEnd = DateTime.Now.AddMinutes(20),

            targetDeliveryStart = DateTime.Now.AddMinutes(-15),

            targetDeliveryEnd = DateTime.Now.AddMinutes(15)

        };

​

        Assert.AreEqual(108m, CalculateDriverPay(order)); 

    }

​

    private static decimal CalculateDriverPay(Order order)

    {

        if (order.status == ORDER_STATUS.REJECTED)

            return 0;

        if (order.status == ORDER_STATUS.CONFIRMED)

            return 1.00m;

​

        decimal pay = order.status == ORDER_STATUS.DROPPED_OFF ? order.baseRate : 0;

​

        if (order.arrivalTime.HasValue && order.arrivalTime >= order.targetArrivalStart && order.arrivalTime <= order.targetArrivalEnd)

            pay += order.baseRate * 0.03m;

​

        if (order.deliveryTime.HasValue && order.deliveryTime >= order.targetDeliveryStart && order.deliveryTime <= order.targetDeliveryEnd)

            pay += order.baseRate * 0.05m;

​

        return pay;

        // ***************************************************************************************************************

        //

        //  Test #7

        //

        //  Rewrite a method that accepts an 'Order' object, and returns the driver pay for the order, given the following

        //    rules:

        //    - If a driver has rejected the order: 0

        //    - If a driver has confirmed the order: $1.00

        //    - If a driver has completed the order (handled both the arrival and delivery): the baseRate

        //    - If the driver arrived within the target arrival window, a 3% bonus on the baseRate is given

        //    - If the driver delivered the order within the target delivery window, a 5% bonus on the baseRate is given

        //

        //  Please add Asserts to validate your solution

        //

        // ***************************************************************************************************************

    }

}

​

​

​