CodeTrigger  

/*IInvoiceSvc.cs*****************/
using System;
namespace Acme.Invoicing.Domain.Interfaces.Services
{
    public interface IInvoiceSvc
    {
        Tuple SaveNewInvoice(int customerId, Tuple[] orders);
        Tuple CalculateDiscount(Tuple[] orderItems);   
     }
}

using System;
using System.Linq;
using Acme.Invoicing.Domain.Interfaces;
using Acme.Invoicing.Domain.Interfaces.Services;

namespace Acme.Invoicing.Domain.Services
{
    public class InvoiceSvc : IInvoiceSvc
    {
        public Tuple SaveNewInvoice(int customerId, Tuple[] orderItems)
        {
            var newInvoice = new BOInvoice();
            newInvoice.CustomerId = customerId;
            newInvoice.InvoiceDate = DateTime.Now;
            newInvoice.SaveNew();

            foreach (var order in orderItems)
            {
                var ivl = new BOInvoiceItem();
                ivl.InvoiceId = newInvoice.Id;
                ivl.ProductId = order.Item1;
                ivl.Quantity = order.Item2;
                ivl.SaveNew();
            }

            var discount = CalculateDiscount(orderItems);
            if (discount.Item2 > 0)
            {
                var discountApplied = new BODiscountApplied();
                discountApplied.InvoiceId = newInvoice.Id;
                discountApplied.DiscountTypeId = discount.Item1;
                discountApplied.ActualDiscountAmount = discount.Item2;
                discountApplied.SaveNew();
            }
            var lineTotals = orderItems.Select(x => new BOProduct(x.Item1).UnitPrice * x.Item2);
            var listTotal = lineTotals.Sum();

            return new Tuple(
                (int)newInvoice.Id, 
                (decimal)listTotal, 
                discount.Item2,
                (decimal)listTotal - discount.Item2)
                ;
        }


        public Tuple CalculateDiscount(Tuple[] orderItems)
        {
            var lineTotals = orderItems.Select(x => new BOProduct(x.Item1).UnitPrice * x.Item2);
            var invoiceTotal = lineTotals.Sum();
            var discountTypes = BODiscountType.DiscountTypeCollection().OrderByDescending(x => x.Threshold);

            IBODiscountType applicableDiscount = discountTypes.FirstOrDefault(x => x.Threshold <= invoiceTotal);

            var applicableDiscountAmt = 0.0M;
            var discountTypeId = -1;

            if (applicableDiscount != null)
            {
                applicableDiscountAmt = invoiceTotal.Value * (applicableDiscount.Rate.Value / 100);
                discountTypeId = (int)applicableDiscount.Id;
            }

            return new Tuple(discountTypeId, applicableDiscountAmt);
        }
    }
}

using System;
using Microsoft.AspNetCore.Mvc;
using Acme.Invoicing.Domain.Interfaces.Services;
using Acme.Invoicing.Domain.Services;
using Newtonsoft.Json;

namespace Acme.Invoicing.Domain.Api.Controllers
{

    public class InvoicingController : Controller
    {
        private IInvoiceSvc _iInvoiceSvc = null;
        /*use a container etc to inject the implementation of InvoiceSvc here through the controller, 
         * to simplify we are instantiating it*/
        public InvoicingController(/*IInvoiceSvc iInvoiceSvc*/)
        {
            _iInvoiceSvc = new InvoiceSvc();
        }

        [HttpPost]
        [Route("applicablediscount")]
        public IActionResult ApplicableDiscount([FromBody]string serialized)
        {
            var orderItems = JsonConvert.DeserializeObject[]>(serialized);
            string ret = JsonConvert.SerializeObject(_iInvoiceSvc.CalculateDiscount(orderItems));
            return Ok(ret);

        }

        [HttpPost]
        [Route("saveneworder")]
        public IActionResult SaveNewOrder([FromBody]string serializedOrder)
        {
            dynamic order = JsonConvert.DeserializeObject(serializedOrder);
            string ret = JsonConvert.SerializeObject(_iInvoiceSvc.SaveNewInvoice(order.CustomerId.ToObject(), order.OrderItems.ToObject[]>()));
            return Ok(ret);

        }
    }
}

using Newtonsoft.Json;
using System;
using System.Net.Http;

namespace Acme.Invoicing.SampleClient
{
    class Program
    {
        private const string InvoicingApiRootUrl = "http://localhost:xxxx";
        static HttpClient client = new HttpClient();

        static void Main(string[] args)
        {
            Console.WriteLine("Sample Demo");
            RunDemo();
            Console.WriteLine("Demo complete. Press enter to exit");
            Console.ReadLine();
        }

        private static void RunDemo()
        {
            //functionality in here depends on the data you have scripted into your db, 
            //eg product ids and discount thresholds
            int someProductId = 3;
            int customerId = 1;

            while (true)
            {
                
                int quantity = 0;
                bool responseInvalid = true;
                Console.WriteLine("Enter new order quantity to purchase, 'X' to quit");

                while (responseInvalid)
                {
                    var e = Console.ReadLine();
                    if (e.ToLower() == "x")
                        return;

                    if (responseInvalid = !int.TryParse(e, out quantity))
                    { Console.WriteLine("invalid quantity value, try again. 'X' to quit");  }
                }
                

                var orderItems = new[] { new Tuple(someProductId, quantity) };
                var serialized = JsonConvert.SerializeObject(orderItems);

                HttpResponseMessage response1 = 
                    client.PostAsJsonAsync(InvoicingApiRootUrl + @"/applicablediscount", serialized).Result;
                response1.EnsureSuccessStatusCode();

                Tuple discount = JsonConvert.DeserializeObject>
                    (response1.Content.ReadAsStringAsync().Result);

                Console.WriteLine($"Your order of {quantity} items qualifies for ${discount.Item2.ToString("0.00")} discount");
                Console.WriteLine("'Y' to continue with purchase, 'N' to try again");
                var e2 = Console.ReadLine();

                if(e2.ToLower() != "y" && e2.ToLower() != "n")
                { Console.WriteLine("invalid response"); }

                else if(e2.ToLower() != "n")
                {
                    var serialized2 = JsonConvert.SerializeObject(new { CustomerId = customerId, OrderItems = orderItems });
                    HttpResponseMessage response2 =
                        client.PostAsJsonAsync(InvoicingApiRootUrl + @"/saveneworder", serialized2).Result;
                    response2.EnsureSuccessStatusCode();

                    Tuple orderResult =
                        JsonConvert.DeserializeObject>
                        (response2.Content.ReadAsStringAsync().Result);

                    Console.WriteLine($"Your order of {quantity} items has been received. ");
                    Console.WriteLine($"Total list price of order is ${orderResult.Item2.ToString("0.00")}");
                    Console.WriteLine($"Discount of ${orderResult.Item3.ToString("0.00")} was applied");
                    Console.WriteLine($"You will be billed ${orderResult.Item4.ToString("0.00")}");
                    Console.WriteLine($"Your invoice reference is #{orderResult.Item1}");
                }
            }
        }
    }
}