In our last series, we moved the ContactTypes from a ColdSpring configured struct, to a database table. This set the stage to move the rest of our persisted data to the database.
As we begin this series our main goal is to have our contacts and lists of contacts stored in our database. Originally, we used in-memory storage as it allowed us a functional application without a database.
In this series, we will introduce two new files, ContactDAO and ContactGW (GW = Gateway). Both components will reside in the *ContactManagerMG.model directory. The ContactDAO will handle the DB work for Creating, Reading, Updating and Deleting our Contacts. Incidentally, this group of functionality is commonly referred to as C.R.U.D. The ContactGW will handle the database work for pulling queries of Contacts. We’ll have a function called getContactQuery().
Here is a look at the ContactDAO. Note: we reference the AppConfig inside our ContactDAO so we can use the Application Configuration defined in ColdSpring. While we mostly care about the DSN for now, the flexibility to pull other configuration parameters will come in handy later.
INSERT INTO Contact
( ContactName, ContactTypeID )
VALUES
(
,
)
SELECT ContactID, ContactName, ContactTypeID
FROM Contact
WHERE ContactID =
UPDATE Contact
SET
ContactName = ,
ContactTypeID =
WHERE ContactID =
DELETE FROM Contact
WHERE contactID =
Here is a look at the ContactGW. Once again we reference the AppConfig.
SELECT C.ContactID, c.ContactName, c.ContactTypeID, ct.ContactType
FROM Contact c LEFT JOIN ContactType ct ON c.ContactTypeID = ct.ContactTypeID
Now we add each component to our ColdSpring configuration. Each component takes one Property, the AppConfig object. Add both beans as new property tags to the existing ContactService bean definition. We will also remove the references to the old Array based ContactList. Let’s do a little housecleaning on our ColdSpring file shall we?
Add the definitions for the components
Remove the following lines from the existing ContactService definition:
Add in the property tags for our new components.
Once complete, ColdSpring will run setContactDAO() and setContactGW() on the ContactService component and stuff the proper object in our service for us. We need to change the service a little now to account for this new functionality. Open up the ContactService and make the following changes:
Remove the getContactList() and setContactList() functions. These functions used to manage our Array based contact list from ColdSpring, with our new Database driven Contact-O-Matic, we won’t need them any longer.
Remove:
Now add in the get/set functions for each component. While we are in here, also add in a new function to get our ContactList from our new ContactGW. The function on the ContactGW is called getContactQuery(). When complete, you’ll have removed two functions and added five. Examples of the new functions are below:
Now our service has references to the ContactDAO and the ContactGW, in turn both the ContactDAO and ContactGW have references to our AppConfig. All the plumbing for the database interaction is complete.
Previously, we stored the ContactType in our ContactFormBean. This was acceptable when referential integrity was not on our list. Now, we need to modify the Contact Form and the Contact Form Bean to refer to the ContactTypeID instead of simply the ContactType. In the form itself, all we need to do is switch the reference. Inside the Bean there is a tiny bit more to it. We will start with the form.
The select tag block should be changed as follows
Type:
Now open the ContactFormBean and change all the ContactType references to ContactTypeID. A find and replace would be nice here. A simply Find and Replace should make 11 changes…
There are two references in the Init() function, one in the validate function and also a get/set block at the bottom. Each of these should be changed to ContactTypeID.
The completed ContactFormBean is here:
Finally, we need to change how the contacts are saved. In the beginning, we simply appended the ContactFormBean object into an Array of ContactFormBean object and iterated over the array for our ContactList. Now, we need to change the controller function to call the service. We will let the service decide how to handle the save. In the controller located at *ContactManagerMG.controller modify the isvalid branch to call a ContactService method called saveContact()
Now add the saveContact() function into your ContactService. This function will accept a Contact object, being our ContactFormBean, and check to see if the ContactID has been assigned. If so, we will update the record, if not, we will create the record. Your saveContact() function should look like this:
After changing the save contact flow, we have closed the circle for adding / updating the individual contacts. Remaining, is the ContactList page.
We will now be returning a query and ourcontact list page used to operate on an array. Thus, we must adjust.
Change your dspContactList.cfm page to use a query. Your completed list page will look as follows:
-No Saved Contacts-
| Name | Type |
|---|---|
| #ContactName# | #ContactType# |
Reset your application and run your new Database Powered Contact-O-Matic. If you’ve followed all the steps, (and I haven’t left any out) you now have a proper application.
We touched a good chunk of the application and I trust this has been a good refresher into the inner workings of our Contact-O-Matic. In our next series, we will include the mechanics to delete contacts from the database.