Sales Tax Problem With Design Pattern

Problem Statement

Basic sales tax is applicable at a rate of 10% on all goods, except books, food, and medical products that are exempt. Import duty is an additional sales tax applicable on all imported goods at a rate of 5%, with no exemptions.

When I purchase items I receive a receipt which lists the name of all the items and their price (including tax), finishing with the total cost of the items, and the total amounts of sales taxes paid. The rounding rules for sales tax are that for a tax rate of n%, a shelf price of p contains (np/100 rounded up to the nearest 0.05) amount of sales tax.

Write an application that prints out the receipt details for these shopping baskets.

Input

1 book at 12.49
1 music CD at 14.99
1 chocolate bar at 0.85

Discussion

Let's say the user buys some products like apples, books or coolers. So, here the design should not be done so that cooler or apple will tell how much tax the user is going to pay. Government policy is responsible for telling the user how much tax he or she is going to pay on it. Object should be responsible for its own concern, and not anyone else's. The concern of a cooler machine is blowing cool air, not charging the tax. If tax law or tax percentage changes, user doesn't change the cooler machine, user needs to change the policy object.

Now, before the application design I will bring up all nouns used in the problem statements and relationship between them. Below are the points,

Sales Tax is a kind of Sales Tax
Import duty is also kind of Sales Tax
Sales Tax has a rate which is a Decimal
Books are a kind of item
Food is a kind of item
Medicines are a kind of item.
Items may be imported
Sales Tax will have some policy which will define that whether sales tax is applicable or not on a given item.
An item has Sales Price in the form of Decimal.
A Receipt containing list of items, price and their taxes
Total Price
Total Tax

Here, we have relationship between all nouns and can start design.

Two basic Classes

Item - It will be an abstract class and Book will inherit from it.
SalesTax - It will be an abstract class and BasicSalesTax class will inherit from it.

In design this problem statement can be modeled as Shopping store and it will have below steps:

A Store will have different kinds of product.
User can put item in cart and purchase it.
Payment counter will calculate Sales Tax as per eligibility of item and price. It will also calculate total price. It will generate bill by containing all details.

Design Pattern Approach

I will use two different kinds of design pattern for the design of Sales Tax Problem. Below are the Design patterns:

Abstract Factory Design Pattern

The Product is an Abstract Super Class and different kinds of items like Book Cooler, Medicine, Food, etc. will inherit from the Product class. It will give the facility to extend the new Product type in future.

Here, main reason to separate class for each product type is that other attributes can be added in the future by just extending the Product class.

So, below classes will be involved,

Abstract Factory - ProductFactory
Concrete Factory - BookProductFactory, FoodProductFactory, MedicineProductFactory
Abstract Product - Product
Concrete Product - BookProduct, FoodProduct, MedicineProduct
Client - StoreShelf

Advantages

If new Product will be added, then there will be no need to change the existing client code.

Strategy Design Pattern

Tax Calculation will be designed by using Strategy Pattern.

So, below classes will be involved,

Strategy - ITaxCalculator
Concrete Strategy - LocalTaxCalculator
Context - Biller

Advantages

We can add new algorithm for Tax Calculation in the feature easily and algorithm can be selected at run time.
The actual creation of a TaxCalculator will be delegated to Factory method.

Sequence Diagram of Sales Tax Problem

Implementation

I will add a short code example. For more details find the attached code.

A Short code of Abstract Factory,

using SalesTax.ProductFactories;
using System;
namespace SalesTax.Products
{
public abstract class Product
{
protected string Name { get; set; }
private double _price;
public double Price
{
set { _price = value; }
get { return _price * Quantity; }
}
public bool Imported { get; set; }
public int Quantity { get; set; }
public double TaxedCost { get; set; }
public Product()
{
this.Name = string.Empty;
this.Price = 0.0;
this.Imported = false;
this.Quantity = 0;
this.TaxedCost = 0.0;
}
public Product(String name, double price, bool imported, int quantity)
{
this.Name = name;
this.Price = price;
this.Imported = imported;
this.Quantity = quantity;
}
public override string ToString()
{
return (Quantity + " " + ImportedToString(Imported) + " " + Name + " : " + TaxedCost);
}
public String ImportedToString(bool imported)
{
if (!imported)
return string.Empty;
else
return "imported";
}
public abstract ProductFactory GetFactory();
public abstract double GetTaxValue(String country);
}
}

using SalesTax.ProductFactories;
using SalesTax.TaxCalculations;
using System;
namespace SalesTax.Products
{
public class BookProduct : Product
{
public BookProduct()
: base()
{
}
public BookProduct(String name, double price, bool imported, int quantity)
: base(name, price, imported, quantity)
{
}
public override ProductFactory GetFactory()
{
return new BookProductFactory();
}
public override double GetTaxValue(string country)
{
if (country == "Local")
return LocalTaxValues.BOOK_TAX;
else
return 0;
}
}
}

using SalesTax.Products;
using System;
namespace SalesTax.ProductFactories
{
public abstract class ProductFactory
{
public abstract Product CeateProduct(String name, double price, bool imported, int quantity);
}
}

using System;
using System.Collections.Generic;
namespace SalesTax.ProductFactories
{
public class BookProductFactory : ProductFactory
{
public override Products.Product CeateProduct(string name, double price, bool imported, int quantity)
{
return new Products.BookProduct(name, price, imported, quantity);
}
}
}

Strategy Pattern Basic Code,

using System;
namespace SalesTax.TaxCalculations
{
double CalculateTax(double price, double tax, bool imported);
}
}

using SalesTax.utils;
using System;
namespace SalesTax.TaxCalculations
{
/// <summary>
/// It Calculates Total Tax Cost According to Local Region Specification.
/// </summary>
public class LocalTaxCalculator : ITaxCalculator
{
public double CalculateTax(double price, double localTax, bool imported)
{
double tax = price * localTax;
if (imported)
tax += (price * 0.5);
//rounds off to nearest 0.05;
tax = TaxUtil.RoundOff(tax);
return tax;
}
}
}

using System;
namespace SalesTax.TaxCalculations
{
public class TaxCalculatorFactory
{
private Dictionary<String, ITaxCalculator> taxCalculators;
public TaxCalculatorFactory()
{
taxCalculators = new Dictionary<String, ITaxCalculator>();
RegisterInFactory("Local", new LocalTaxCalculator());
}
public void RegisterInFactory(string strategy, ITaxCalculator taxCalc)
{
taxCalculators.Add(strategy, taxCalc);
}
public ITaxCalculator GetTaxCalculator(String strategy)
{
ITaxCalculator taxCalc = (ITaxCalculator)taxCalculators[strategy];
return taxCalc;
}
public int GetFactorySize()
{
return taxCalculators.Count;
}
}
}

Implementation of this Sales Tax Problem is very large so I could not include here. I added Zipped project. Take reference from there.

Conclusion

Sales Tax Problem teaches and makes us think about the design approach. So, here Abstract factory and Strategy Design Patterns have been applied. It is a very good problem statement to think and design applications by using design patterns.