Declaration of Classes

To keep things organized in the code, we will keep all the declarations of the classes in one unit. Add a new unit to the project (you can use the Add New ➤ Unit option from the popup menu, as shown in Figure 2-5) and save it as Declarations.pas. Then, add the following code to the unit.

unit Declarations;

interface

type
  TCustomer = class
  private
    fID: Integer;
    fName: string;
    fDiscountRate: Double;
    fBalance: Currency;
  public
    property ID: integer read fID write fID;
    property Name: string read fName write fName;
    property DiscountRate: double read fDiscountRate write fDiscountRate;
    property Balance: Currency read fBalance write fBalance;
  end;

  TItem = class
  private
    fID: Integer;
    fDescription: string;
    fPrice: Currency;
  public
    property ID: integer read fID write fID;
    property Description: string read fDescription write fDescription;
    property Price: Currency read fPrice write fPrice;
  end;

  TInvoice = class
  private
    fID: integer;
    fNumber: integer;
    fCustomerID: integer;
  public
    property ID: Integer read fID write fID;
    property Number: Integer read fNumber write fNumber;
    property CustomerID: Integer read fCustomerID write fCustomerID;
  end;

TInvoiceItem = class
  private
    fID: integer;
    fInvoiceID: integer;
    fItemID: integer;
    fUnitPrice: Currency;
    fQuantity: integer;
  public
    property ID: integer read fID write fID;
    property InvoiceID: integer read fInvoiceID write fInvoiceID;
    property ItemID: integer read fItemID write fItemID;
    property UnitPrice: Currency read fUnitPrice write fUnitPrice;
    property Quantity: Integer read fQuantity write fQuantity;
  end;

implementation

end.

The Database Unit

Create a new unit and save it as Database.pas. This unit represents the persistent medium of your application. In a real-life application, you are most likely to use local and/or remote databases but, in this case, we will use hard-coded data. We will generate customer records, balances, and discount rates manually in the Create event of the class.

Now we will create a TDatabase class to simulate the “persistent” data. In the interface section of the Database.pas unit, add the following code:

uses Declarations, System.Generics.Collections;

type
  TDatabase = class
  private
    fCustomers: TObjectList<TCustomer>;
    fItems: TObjectList<TItem>;
  public
    constructor Create;
    destructor Destroy; override;
  end;

The class we created does not offer a way to expose the private fields. At this stage, we will use the constructor to simulate the creation of records in a “persistent” medium, as described. Later in this chapter, we will develop the class further to provide access to the private fields according to our needs.

The code in the implementation section for the constructor and deconstructor is as follows. As you can see, we create a set of customers and items to resemble data retrieved from dynamic storage.

{ TDatabase }

constructor TDatabase.Create;
var
  tmpCustomer: TCustomer;
  tmpItem: TItem;
begin
  inherited;

  fCustomers:=TObjectList<TCustomer>.Create;  

  //Create mock customers
  tmpCustomer:=TCustomer.Create;
  tmpCustomer.ID:=1;
  tmpCustomer.Name:='John';
  tmpCustomer.DiscountRate:=12.50;
  tmpCustomer.Balance:=-Random(5000);
  fCustomers.Add(tmpCustomer);

  tmpCustomer:=TCustomer.Create;
  tmpCustomer.ID:=2;
  tmpCustomer.Name:='Alex';
  tmpCustomer.DiscountRate:=23.00;
  tmpCustomer.Balance:=-Random(2780);
  fCustomers.Add(tmpCustomer);

  tmpCustomer:=TCustomer.Create;
  tmpCustomer.ID:=3;
  tmpCustomer.Name:='Peter';
  tmpCustomer.DiscountRate:=0.0;
  tmpCustomer.Balance:=-Random(9000);
  fCustomers.Add(tmpCustomer);

  tmpCustomer:=TCustomer.Create;
  tmpCustomer.ID:=4;
  tmpCustomer.Name:='Retail Customer';
  tmpCustomer.DiscountRate:=0.0;
  tmpCustomer.Balance:=0.0;
  fCustomers.Add(tmpCustomer);

  fItems:=TObjectList<TItem>.Create;
  //Create mock items to sell
  tmpItem:=TItem.Create;
  tmpItem.ID:=100;
  tmpItem.Description:='T-shirt';
  tmpItem.Price:=13.55;
  fItems.Add(tmpItem);

  tmpItem:=TItem.Create;
  tmpItem.ID:=200;
  tmpItem.Description:='Trousers';
  tmpItem.Price:=23.45;
  fItems.Add(tmpItem);

  tmpItem:=TItem.Create;
  tmpItem.ID:=300;
  tmpItem.Description:='Coat';
  tmpItem.Price:=64.00;
  fItems.Add(tmpItem);

  tmpItem:=TItem.Create;
  tmpItem.ID:=400;
  tmpItem.Description:='Shirt';
  tmpItem.Price:=28.00;
  fItems.Add(tmpItem);
end;

destructor TDatabase.Destroy;
begin
  fCustomers.Free;
  fItems.Free;
  inherited;
end;

Total Sales

The main screen of POSApp has a field that shows the total sales figure. If we want to implement this, we need to have a way to store the sales that we generate every time we issue an invoice. As before, in real-life applications, this figure is typically stored in a database or calculated on-the-fly by accessing a database. Here, I use a normal text file to keep track of the invoice amounts. This is, admittedly, a naïve and poor approach, but it will serve our purposes. Delphi provides a very handy way to meet our needs, by providing the TIniFile class.

In the TDatabase class, add one private field to hold the path and the filename of the file and two procedures to retrieve (GetTotalSales) the total amount and save (SaveCurrentSales) each invoice’s sales amount. You also need to update the constructor and the uses clause in the implementation section.

We initialize the value of fFullFileName to point to the folder of the executable file. If your target is set to Win32 and the build configuration is set to Debug, the POSApp.data file will be created in:

{the path you store the project files}Win32Debug

GetTotalSales opens the INI file and loads the Total Sales value from the Sales section of the file. SaveCurrentSales takes the amount of the current invoice and adds it to the saved sales figure.

Retrieving Data

Switch back to the Database unit and add the following functions to the TDatabase class. Now, we will add methods to expose the private fields we declared earlier.

interface
 ...

type
  TDatabase = class
  private
    ...
  public
    ...
    function GetCustomerList: TObjectList<TCustomer>;
    function GetItems: TObjectList<TItem>;
    ...
  end;

implementation

...

function TDatabase.GetCustomerList: TObjectList<TCustomer>;
begin
  result:=fCustomers;
end;

function TDatabase.GeTItems: TObjectList<TItem>;
begin
  result:=fItems;
end;

These functions simply return the lists from the TDatabase class. Back to InvoiceForm, the SetupGUI procedure cleans the edit field and the string grid and makes the animated progress indicator and the label at the bottom invisible. If you execute POSApp and open an invoice, you should be able to select a customer from the popup box.

The last thing that is left to do in the Customer Detail group box is to update the Discount Rate and the Outstanding Balance fields that appear when the user selects a customer name in the popup box. In the Database unit, the customer list is stored as an object list of TCustomer classes. When the user makes a selection in the popup box for the customers, we only have the name of the customer. Therefore, we need a way to get the TCustomer class from the name. Go back to the Database unit and add the following function.

interface

...

type
  TDatabase = class
  private
    ...
  public
    ...
    function GetCustomerFromName(const nameStr: string): TCustomer;
    ...
  end;

implementation

function TDatabase.GetCustomerFromName(const nameStr: string): TCustomer;
var
  tmpCustomer: TCustomer;
begin
  if not Assigned(fCustomers) then Exit;
  result:=nil;
  for tmpCustomer in fCustomers do
  begin
    if tmpCustomer.Name=nameStr then
    begin
      result:=tmpCustomer;
      exit;
    end;
  end;
end;

Now we have a way to retrieve the TCustomer class from the customer name. Switch to the InvoiceForm unit, click on the OnChange event of the PopupBoxCustomer component, and add the following code:

The code is straightforward; after retrieving the appropriate TCustomer class, it updates the user interface accordingly and enables the relevant parts. The code also cleans the string grid when the customer popup menu changes.

Similar to the need we had earlier to retrieve the customer class from the name, we need to be able to get the item’s class from its description. In the Database unit, add the following method.

type
  TDatabase = class
  private
    ...
  public
    ...
    function GetItemFromDescription(const desc: string): TItem;
    ...
  end;
...

implementation
...

function TDatabase.GetItemFromDescription(const desc: string): TItem;
var
  tmpItem: TItem;
begin
  result:=nil;
  if not Assigned(fItems) then Exit;
  for tmpItem in fItems do
  begin
    if tmpItem.Description=desc then
    begin
      result:=tmpItem;
      exit;
    end;
  end;
end;

Updating the Form

The PopupBoxItems menu is enabled when the user selects a customer. We will add the code to update the list with the selected item and the quantity. Click on the Add Item button and add the following code.

The method applies a number of validation checks and adds the new invoice item to the fCurrentInvoiceItems list. We update the user interface (the string grid and the label with the total invoice amount) using the two procedures at the end of the previous method. You can develop the two procedures with the following code.

We need to add the code for the GetItemFromID procedure (Database unit), which appears in UpdateInvoiceGrid, as indicated previously.

type
  TDatabase = class
  private
    ...
  public
    ...
    function GetItemFromID(const id: Integer): TItem;
    ...
  end;
...

implementation
...

function TDatabase.GetItemFromID(const id: Integer): TItem;
var
  tmpItem: TItem;
begin
  result:=nil;
  if not Assigned(fItems) then Exit;
  for tmpItem in fItems do
  begin
    if tmpItem.ID=id then
    begin
      result:=tmpItem;
      exit;
    end;
  end;
end;

Run the application. You should be able to add items in the invoice and then view the updated invoice amount.

There are a few things left. In the InvoiceForm, select the PopupMenuItems popup menu component, open the Items Editor, and open a TMenuItem labeled Delete Entry. Select the menu item you created and implement the OnClick event.

interface
...

type
  TSalesInvoiceForm = class(TForm)
    ...
    procedure MenuItemDeleteItemClick(Sender: TObject);
  private
    ...
  public
    { Public declarations }
  end;

...

implementation

...
procedure TSalesInvoiceForm.MenuItemDeleteItemClick(Sender: TObject);
var
  tmpInvoiceItem: TInvoiceItem;
begin
  if (StringGridItems.Selected>=0) and
    (StringGridItems.Selected<=StringGridItems.RowCount-1) then
  begin
    for tmpInvoiceItem in fCurrentInvoiceItems do
      if tmpInvoiceItem.ID=
        StringGridItems.Cells[4,StringGridItems.Selected].ToInteger then
        begin
          fCurrentInvoiceItems.RemoveItem(tmpInvoiceItem, TDirection.FromBeginning);
          break;
        end;
  end;
  UpdateInvoiceGrid;
  UpdateBalance;
end;

Select the CheckBoxDiscount check box and write the OnChange event to update the discounted amount, as you have already considered the discount in UpdateBalance.

interface
...

type
  TSalesInvoiceForm = class(TForm)
    ...
    procedure CheckBoxDiscountChange(Sender: TObject);
  private
    ...
  public
    { Public declarations }
  end;

...

implementation

...
procedure TSalesInvoiceForm.CheckBoxDiscountChange(Sender: TObject);
begin
  UpdateBalance;
end;

When the user is ready to issue an invoice, they select the Print Invoice button. If they want to cancel it, they simply select Cancel. The code behind the OnClick events of the two buttons looks like this:

The Cancel button simply closes the form and the Print Invoice button shows a message and stores the invoice amount to our “database”.

At this point, we have completed the POSApp. As you see, this implementation provides the code that accesses our database and performs calculations (the business logic) next to the code that updates the user interface (the presentation). If you want to replace the form with another one, you need to spend a lot of time and effort developing all the procedures of the new form. In fact, it does not have to be a completely new form. You can face the same difficulty if you replace components in the form.

For example, in the SalesInvoiceForm unit, we run a few calculations in several places and update the GUI elements accordingly. If, at some point, we want to show the discount rate in a pie chart or add a track bar to allow users to define the quantities to the invoice items, we would need to visit all those places in the form and amend the code that retrieves or shows this information. These kinds of complications, which are prone to errors and bugs, are minimized and even avoided with the MVVM approach.