Bruce Gust | Object Oriented Programming

Object Oriented Programming PHP Tutorial

Object Oriented Programming: The Journal of an Idiot
Bruce Gust

Here's my dilemma and my goal: I've got to build an application that would normally be "cake and ice cream" if I allowed myself the luxury of building it using a Procedural approach. But I'm determined to build it using OOP simply because it's a healthy thing to stay current on contemporary models and frameworks. I'm going to document things as I attempt to get my brain around all this and then chronicle how I attempted to implement those things as I built my application. Buckle up! Here we go! Contents: I) The Basics II) What's a Class? A) What's a Property? 1) Visibility B) Using Construct 1) Initializing 2) What is "$this->"? C) Constants III) Some Practical Application A) Writing a CSV File - lots of great functionality here as far as how to write a CSV file in the context of an OOP approach

Establishing a Connection to the Database
Documenting an Error
Number of Rows

B) Parsing a JSON File

Scanning a Directory
Destroy Specified Variables in an Array - unset
Opening a GZ File
A Real World Function

IV) Model, View, Controller A) Intro B) The "Controller" C) The "Model" D) The "View" BTW: In some instances, I've documented the code using a little "code box," but in other instances, where the situation seemed to warrant it, I wrote it out and incorporated color coded some comments in green to make it stand out from the code which is written in blue. FYI: Here are some great sites that provide some wonderful background and theory: w3resource.com PHPro CSS Tutorial (selectors and more...) Also, for the sake of being able to document code, click here to access the "code machine." All you'll do is enter your raw code and the script will then enter the appropriate CSS tags so you can then display it like what you see here.

I) Basics

Here's the way I'm looking at OOP: With a Procedural approach, you have to stick the key in the ignition and start up the car every time you want to give your user a chance to access information in a database. With OOP, you start the car one time. You do all the heavy lifting up front and then it's just a matter of grabbing information that's already been retrieved and / or processed. Kind of cool...

Before we get into Functions and Classes and other definitions, there's a very cool "bottom line" that's worth rehearsing before we get into all this. You can write funtions and still not be doing OOP. "So what's the difference between writing functions and OOP" you ask. Simply put, OOP is the next step in "grouping" blocks of code together in order to facilitate more proficiency. For example, you have straight ahead Procedural code where I'm coding a task every time I need it in the context of my page like this: <?php echo "hello"; ?> ...or you could write it as a function like this: <?php //you write this one time at the top of your page function say_something(); echo "hello"; ?> <?php say_something(); ?> The advantage of doing things using Functions is that if you had to go back and instead of saying "hello," you wanted to say "wuddup," depending on the size of your app, you've got a lot of work ahead of you. On the other hand, if you used a Functional approach, you just have to change the one line in your function from "hello" to "wuddup" and you're done. Do you see where we're going with all this? Instead of writing a task every time you want to use it, you write it one time and in so doing you "group" your tasks together in one location rather than have them scattered throughout your app. With OOP, you take the concept of "grouping" a step further in that you're actually grouping your Functions into things called Classes. Now you're looking at something like this: class say_something { public $hello; public $wuddup; public function __construct(){ $this->hello="hello"; $this->wuddup="wuddup?"; } public function speak() { echo $this->hello.' '.$this->wuddup; } } So, now you've got even more functionality in that you can accomplish several things in the context of a Class where you've got multiple functions happening simultaneously. Again, if you had to write "hello" and "wuddup" in the context of a single line of PHP code throughout your app, you're stuck if you've got to make a global change. With OOP, now you have a place where you're doing all your heavy lifting in one place. You make your alteration in that one centralized location and you've impacted your entire app without having to go through things line by line. Here we go...

Some basic elements that you need to be familar with:

II) Classes

Depending on how you're wired mentally, my illustrations may or may not resonate with you and I've seen several different explanations of what a "class" is, but this is the illustration I landed on that allowed the "class" to make sense to me. When you create a blank spreadsheet, you're creating a class. You've got columns (aka "properties") and you've got rows, but you don't refer to them as columns and rows. Rather, you've got some other terminology to consider. We'll get into this more later, but no doubt you've heard the term "functions." The difference between a function and a class is that with a class you typically

have several functions that have been grouped together because of some kind of similiarity in the tasks they perform
you also have have the capacity for default values to be established (again, aka "properties")

So, in that regard you have something where a spreadsheet is a very apt illustration in that you can envision how certain "cells" can have functions built into them. OK, onward... A) What's a Property?

snare

kick

hihat

The column names are referred to as "properties" but you don't have any info. You'll populate the columns / rows in a little bit with some actual information, but as far as what a basic property within a Class is, think of a blank spreadsheet with column names like what you see to the right. As far as the syntax is concerned, that would look like this: class MyDrumset { public $snare; public $kick; public $hihat; } In this example, you've got a Class called MyDrumset and you have three properties (column headings); $snare, $kick and $hihat. 1) Visibility

When you see "public," don't freak. You've got three classifications of properties within a class and they are as follows:

public: Public properties and methods can be accessed anywhere in a script after the object has been instantiated
protected: Protected properties and methods can be accessed only within the class that defines them, parent classes, or inherited classes
private: Private properties and methods can only be accessed by the class that defines them

Bottom line: How you define your properties will determine the extent to which they're available throughout your app. For now, we're calling everything "public." It's worth it to pause and consider what these three types of properties look like. The illustration to the right shows you how these types of properties can and should be used and how their definition plays out practically. Imagine we've got a function that is going to upload a CSV file. At the top you've got something like this: Class MyCSV { public $csv; protected $header; protected $data; The three properties that are established at the beginning consist of two "protected" properties and it makes sense. Given the fact that "$header" and "$data" are common terms and things that could easily get confused with other elements, you want to ensure that the wires aren't going to cross so you make them "protected."

The "official" term that applies the different types of properties is "visibility," and you can find more info about that in the PHP Manual. It has a great example on how "public, protected and private" variables can be accessed in the context of a page based on the visibility they've been assigned.

B) Using the Construct (_constructor) - the "rows..." Now, let's add some "rows" to our "class." Remember, all we've got right now is a blank spreadsheet with column names. Now we're going to add some "rows." The cells are blank in this example, although you could hardcode some values into them. In this instance, we're just establishing some scaffolding. This gets back to what was stated earlier as far as the difference between Classes and Functions being that with a Class you have both data and functions. While functions are machines that are manipulating data, a Class has the capacity to manipulate data as well as store data within itself. Again, think of a spreadsheet. Right now, we've got three column headings but we have no rows beneath them. Now watch... Here's the syntax: class MyDrumset { public $snare; public $kick; public $hihat; public function __construct($three, $blind, $mice) (This is important! The "construct" word is prefaced with two underscores (__), not one!) { $this->snare=$three; $this->kick=$blind; $this->hihat=$mice; } }

snare	kick	hihat

...and if your refer to the little table to the right, you can see what this looks like using our "spreadsheet" example: 1) Initializing Using the constructor and establishing digital placeholders that coincide with each of our three properties is called "initializing." It's not a term limited to OOP or Classes, but it's the term used here nevertheless.

The Construct function is more important than you might imagine. At one point, I was crafting a Class and positioning Functions in a way where I was assuming they were talking to one another. In other words, I used a Function to define a variable based on a posted piece of data coming from a form. I then moved on in my logic to the next function where I took this newly declared variable and proceeded to write some code around it only to find out after the fact that Functions don't really talk to one another, even when housed in the same Class. If you've got more than one Function sharing a piece of data, define that using your Construct function. Like this:

class StoreCSV {
public $csv;
protected $data;
public function __construct() { //right here is where I'm talking about
if(empty($_POST['csv_name']))
{
print "there's no CSV to look at";
}
else
{
$this->csv=$_POST['csv_name'];
}
}
public function loadCSV()
{
global $mysqli;
$this->csv_file_name="csv/$this->csv"; //$this->csv is "seen" by loadCSV because it has been correctly defined by the construct function on line 5
//return $this->csv_file_name;
var_dump($this->csv_file_name);
$handle=fopen($this->csv_file_name, "r");
}
}

When you look at line 5, that one little construct element is what made all the difference. Previously I had written a function where I defined the variable and then expected my function on line 15 to recognize $this->csv and it didn't. You have to use the construct function to define your properties. It's only then that the rest of the Functions in your Class will be able to "see" that data.

2) What is "$this?" BTW: That "$this->snare=$snare;" thing... "$this->" is defined in the PHP Manual as...

The pseudo-variable $this is available when a method is called from within an object context. $this is a reference to the calling object (usually the object to which the method belongs, but possibly another object, if the method is called statically from the context of a secondary object).

If you're wondering where "$three, $blind, $mice" came from, fret not. What we're going to be doing in just a moment is passing three variables into our Method and those variables could be called anything. We could've called them "$moe, $curly and $larry." It's not the name as much as it's how we're identifying the digital "cell" that corresponds to the "column" of the of the digital spreadsheet that we've created that gives us a way to organize the data that's going to be arriving in just a moment.

It's just a geeky way of putting your finger on something and identifying it as part of the "thing" that you're looking at. So, with the example we're using, the '$this->' code is saying that 'As far as the class MyDrumset is concerned, the 'snare' variable is the cell / row that coincides with the '$snare' column we defined earlier.' It's just a way of mapping things out and giving everything a unique address / meaning within your code. Another way of looking at it is to envision a "tree." Whether it's "this" or any other idenfier, you're basically acknowledging a digital "tree" that's been created. That "tree" has any one of number of branches that can be grabbed on to programmatically. So when I say "$this->..." I'm taking hold of a "branch" that belongs to the "this" tree. I've also heard it referred to as the "arrow operator." Bottom line, it's what you're using to identify or specifiy a digital entity. C) Constants You use "Construct" do define a variable that is generally unique / relevant to one or perhaps a couple of Functions within a particular Class. It can be "fluid," in that it can be defined according to data that's arriving via a form or something similar. In other words, it's foundational, but it's something that could conceivably be altered or changed depending on how you've crafted your code. A "Constant" on the other hand is usually hard coded into your script. It is immutable, for the most part. Very handy, but something you use only when you want to define something you don't see needing to change anytime soon. A good example might be the root directory of your app. For example... const ROOTURL='http://www.brucegust.com'; Something to keep in mind!

Before we get into some practical application, it's good to rehearse some good practices as far as things you want to include in your code every time. Always include: error_reporting(E_ALL); sometimes you may want to use "error_reporting(E_ALL ^ E_STRICT); " in the event you want to omit the errors generated by "E_STRICT" which hightlights code that is subject to be changed or deprecated. echo '<pre>'; "error_reporting(E_ALL)" tells your code to document errors wherever they may occur and the "<pre>" dynamic ensures that when any kind of text is printed, you get the appropriate line breaks included so the resulting errors. So, with echo '<pre>' you get : $this is defined (A) $this is not defined. $this is defined (B) $this is not defined ...otherwise, you get: $this is defined (A) $this is not defined. $this is defined (B) $this is not defined.

D) Let's Do Something Now, check this out: We've defined a "class" as being something akin to a spreadsheet. That illustration actually works well because an Excel Spreadsheet is capable of doing more than just arranging data in the context of columns and rows. You can actually write formulas and do something with that data rather than merely displaying it - that's what you can do with a Class and a Function within an OOP enviornment. Quick FYI: A function written within a class is called a "Method." That's important because you can write functions outside of a Class. But when you write them as part of your "Class" (spreadsheet), you call it a "Method." Look at this: class MyDrumset { public $snare; public $kick; public $hihat; public function _construct($three, $blind, $mice) { $this->snare=$three; $this->kick=$blind; $this->hihat=$mice; } See, right here I'm going to add some functionality and print something. Yes, you see the word "function," but because it's written within a Class, it's actually called a "Method." public function printSomething() { print "Ideally, my "dream" drum kit consists of a {$this->snare} snare, a {$this->kick} bass drum and a pair of Sabian "{$this->hihat}" hihats."; } } Do you feel the energy? You smell something cooking on the stove, do ya? Alright... We've got some scaffolding and we've got a Method written within our class, so now let's create an "Object." Oooo... E) Objects "Objects" are specific pieces of info that can now make sense because we're going to refer to them in the context of the Class that we previously defined. You see how all this is coming together? So, here's my "object:" $kit1 = new MyDrumset("Yamaha Piccolo", "28 inch", "Quickbeat"); $kit1->printSomething(); Again, you might be wondering "Where did you get '$kit1' from?" Again, it's not something you need to be concerned about, in terms of naming conventions. In order to use whatever functionality we've just created, we have to create a digital placeholder for it. The technical term is "instantiate." It's basically saying "I want the digital magic that I've just crafted to happen right...here!" So, in this example, I'm "instantiating" the MyDrumset class by programmatically saying "I want the 'MyDrumset' class to happen at this particular point in my page." In other words, I'm saying that I want to print, "Ideally, my "dream" drum kit consists of a {$this->snare} snare, a {$this->kick} bass drum and a pair of Sabian "{$this->hihat}" hihats." See how this is working? I've got three "cells" in my spreadsheet and I'm dictating what each of the values are in my "row" that I set up using my "constructor" function and now I'm passing three variables into what will be the "print" dynamic of my class. It's worth taking a second look at the way we instantiated "new MyDrumset" in that the order of the elements within the paranthesis has to coincide with the "$three, $blind, $mice" dynamic we set up a moment ago. Remember? The "construct" part of our Method was: public function _construct($three, $blind, $mice) { $this->snare=$three; $this->kick=$blind; $this->hihat=$mice; } So whatever occupies the position of "$three" is going to be processed as the "snare." Whatever is in the number two position of "$blind" is going to be intrpreted as the kick and so on. So, the result of my "$kit1" object is:

Ideally, my "dream" drum kit consists of a Yamaha Piccolo snare, a 28 inch bass drum
and a pair of Sabian "Quickbeat" hihats.

Before we proceed, let me pause long enough to elaborate a little on what we've just looked at... - "Classes" represent not just one "task," but potentially multiple tasks being performed every time you instantiate an instance of that Class. - "Functions" are individual tasks. The basic concept is the same in that you'll be passing variables into said "task," but where a Class has potentially several functions / tasks (and again, they're referred to as "Methods" when being executed within a Class), a Function is one solitary "thing" being done. - The Class begins with the definition of some Properties and in our example we did a "construct" where we established some placeholders - otherwise known as Objects - that corresponded to those Properties, much like a spreadsheet where the column headings were our Properties and the cells below each one of those column headings were our Objects.

III) Some Practical Application

Now, let's take a look at a real life piece of script and break it down. This is a script that's pulling from a database and then exporting that data into a CSV file. Very handy... There isn't any kind of "function" going on in this code, but that's what makes it a good starting point, just so you can see how things compare between a Procedural approach and an OOP approach. Ocassionally you'll see some notes in green that shows how the same code would've been written using a Procedural approach just so you can see how things would've been written. A) Arrays Returned Within a Function Let's start with this: You're probably accustomed to selecting something from a database and then looping through the selected rows using a "while" dynamic. Perfectly fine... But, when you're using a function to select more than one particular piece of information, you're going to be storing the results of that query in a single "box." Again, going back to the spreadsheet illustration. When you're deploying a procedural approach, you query a database and you run through your results as a collection of rows. In that way, you've got a separate "box" for every row's worth of information. When you're using an OOP, you're select statement is typically stored within a function where you're returning a single "box" comprised of multiple rows - each row being tagged with a default value. Check it out: view "arrays within a function code... B) CSV File Creation Here's an example of converting the results of a select statement and turning it into a downloadable CSV file. Take a look... view "CSV File Creation..."

Here's a quick little "key" so you can see some of the highlighted examples referenced in the Table of Contents... Establishing a Connection to the Database Documenting an Error Number of Rows <?php ini_set("memory_limit","500M"); error_reporting(E_ALL); set_time_limit(600); include ("carter.inc"); Normally, you would use this code to initate your database connection: $cxn = mysqli_connect($host,$user,$password,$database) or die ("couldn't connect to server"); ..but we do things a little different in OOP in that we're establishing a $mysqli object and bringing into the credential process the info contained with carter.inc $mysqli=new mysqli($host, $user, $password, $database);...here's the OOP way of connecting to the database if($mysqli->connect_errno) { $err = "Connection failed:" .$mysqli->connect_errno - see how we're grabbing a "branch" from the "$mysqli tree...?" .' ' . $mysqli->connect_error ; trigger_error($err, e_user_error); } $sql="select * from twitter_csv order by id"; - here's our sql statement. $res=$mysqli->query($sql); - we're instantiating the whole select statement by using "$res." "query" is a programmatic "branch" that we can grab on to that stems from the $mysqli object and that's our query right there if(!$res = $mysqli->query($sql)) //connecting to a database { $err = 'Query Failure:' .'errno: ' .$mysqli->errno . ' error: ' .$mysqli->error . 'query: ' . $sql; trigger_error($err, e_user_error); } $cnt=$res->num_rows; - very cool way of looking to see if we've got any data. This looks familiar based on the way we would do it in a procedural environment as far as mysqli_num_rows. Same thing, just written differently. if($cnt==0) $michelle_columns=mysqli_field_count($cxn); // WRITE A CSV FILE HERE - and here's where we're writing our CSV file! $out = 'csv/twitter.csv'; $fpw = fopen($out, 'wb'); if (!$fpw) trigger_error("Unable to Open $out", E_USER_ERROR); // GET COLUMN NAMES $fld = $res->fetch_fields(); $csv = array(); foreach ($fld as $obj) { $csv[] = $obj->name; } fputcsv($fpw, $csv); // GET DATA VALUES while ($row = $res->fetch_assoc()) { fputcsv($fpw, $row); } fclose($fpw); /*header("Location:csv/index.php"); exit();*/ /*$filename="twitter.csv"; header('Content-type:application/csv'); header('Content-Disposition: attachment; filename='.$filename);*/ echo PHP_EOL . 'Your CSV file can be downloaded by clicking <a target="_blank" href="' . $out . '">here</a>'; ?> hide "CSV File Creation..."

C) Parsing of a JSON File In this example, you've got a lot of moving parts, but it's really cool to see how this functality works. You have a directory of compressed JSON files. Mind you, it's a directory. It's not a table in a database, it's a collection of files sitting in a file somewhere and we're going to be using code that can "see" those files. From there, we're going to be grabbing those files one at a time and "parsing" them. To parse a file basically means that you're breaking a pile of data into meaningful pieces - very handy. Click on the link above to see an example. This example uses a function, so you can start to see the utility of an OOP approach in that you do the heavy lifting once and then just benefit from its labor using minimal code for the rest of the app / page. Again, you'll see some notes in green that shows how the OOP script compares to its Procedural counterpart. Here we go... show "Parsing of a JSON File..."

Scanning a Directory Destroy Specified Variables in an Array - unset Opening a GZ File A Real World Function //here is where you're putting your "eyes" on the directory where all of the gz files are located $dir = 'twitter_gz'; //this is the physical location of the directory relative to the url of the page $arr = scandir($dir); //"scandir" is a PHP function where it's looking at the contents of the $dir directory which you defined as the folder entitled "twitter_gz" a moment ago unset($arr[0]); //you've got some "files" that were a part of the directory that were "." and ".." - literally. By "unsetting" these members of the array, you ensure that they're not included in the processing that's about to take place unset($arr[1]); foreach($arr as $file) //now you've got an array devoid of superflous dealbreakers and you can start parsing them { This next chunk of code is updating a database that has the name of every file in the table along with a timestamp that designates when the parsing process started and when it completed. This was a good way of keeping track of what was happening as well as what had already occured. //check to see if this file has already been processed $no_date=strtotime('0000-00-00 00:00:00'); $bruce = "SELECT id, file_name, start_time from zipped_files where file_name='$file' and completed=1"; $bruce_query = $mysqli->query($bruce); $bruce_count = $bruce_query->num_rows; if($bruce_count==1) { $bruce_row = $bruce_query->fetch_object(); $bruce_id=$bruce_row->id; //I've got to check to see if this one has been started. If so, move on to the next one in the array if($bruce_row->start_time<>"0000-00-00 00:00:00") { continue; } else { $now=date('c'); $crystal = "update zipped_files set start_time='$now' where id = $bruce_id"; $crystal_query=$mysqli->query($crystal); // LOAD THE DATA INTO THE TABLE $url = 'twitter_gz/'; building the URL of the file you're getting ready to parse $url .= $file; $gzf = gzopen($url, 'r'); using the PHP function of opening a .gz file and the "r" represents one of the modes in which you can open it //$tmr->stop('gzopen'); this is part of timer function that was built to measure how long it took for the process to finish // COUNT THE LINES, SKIPPED, DUDS, AND LOADED $cnt = $skp = $dud = $ldd = 0; while (!gzeof($gzf)) { set_time_limit(2); $cnt++; $doc = gzgets($gzf, 12000); gzgets is another PHP function. The first argument is the actual file that you defined a moment ago. The next argument is the length of the data to retrieve. $doc = trim($doc); if (empty($doc)) { $skp++; //echo ' '; continue; } $sql = makeQuery($doc); HERE'S YOUR FUNCTION- Notice the $doc variable which is your "gzgets" thing that you defined a moment ago if ($sql) we gave our makeQuery() function a digital presence with $sql. If that function happened, we should have some digital entities in place. { if (!$res = $mysqli->query($sql)) we're making a placeholder for the possibility of an error so we can see whether or not the query ($qry) within the function fired correctly { $err = 'QUERY FAILURE:' . ' ERRNO: ' . $mysqli->errno . ' ERROR: ' . $mysqli->error . PHP_EOL . 'QUERY: ' . $sql . PHP_EOL . 'LINE: ' . $cnt ; trigger_error($err, E_USER_WARNING); } else { $ldd++; represents the number of rows loaded } } else { //echo "LINE $cnt: DUD: $doc"; the function didn't fire, so we've got a dud //$dud++; } } the funtion fired and we're done parsing all of the rows. Now we update the table that's keeping track of all that we're doing and that's that! $done=date('c'); $ray = "update zipped_files set completed = 2, end_time='$done' where id=$bruce_id"; $ray_query=$mysqli->query($ray); header("Location:breather.php?id=$bruce_id"); exit(); } //this curly bracket ends the if function that was looking to see if this file had been processed //here we're redirecting to the "breather" page that gives the program a break so it doesn't time out } } echo "you're finished!"; function makeQuery($doc) OK, here's the function that's being called at line 360 { global $mysqli; grabbing the global variable of "$mysqli" which is your connection data $jso = json_decode($doc); you're using the PHP function of json_encode which is encoding the JSON data if (!$jso) return FALSE; escaping and positioning all your JSON data and getting ready to insert it into the database $twitter_id = !empty($jso->id) ? explode(':',$jso->id) : array(NULL, NULL, NULL); $twitter_id = $mysqli->real_escape_string($twitter_id[2]); $actor_id = !empty($jso->actor->id) ? explode(':',$jso->actor->id) : array(NULL, NULL, NULL); $actor_id = $mysqli->real_escape_string($actor_id[2]); $actor_display_name = !empty($jso->actor->displayName)? $mysqli->real_escape_string($jso->actor->displayName): NULL; $posted_time = !empty($jso->postedTime)? $mysqli->real_escape_string($jso->postedTime): NULL; $display_name = !empty($jso->generator->displayName) ? $mysqli->real_escape_string($jso->generator->displayName) : NULL; $geo_coords_lat = !empty($jso->geo->coordinates[0]) ? $mysqli->real_escape_string($jso->geo->coordinates[0]) : NULL; $geo_coords_lon = !empty($jso->geo->coordinates[1])? $mysqli->real_escape_string($jso->geo->coordinates[1]): NULL; $location_name = !empty($jso->location->name)? $mysqli->real_escape_string($jso->location->name): NULL; $posted_day = !empty($jso->postedTime)? $mysqli->real_escape_string(date('Y-m-d', strtotime($jso->postedTime))) : NULL; $qry here's your actual query = " INSERT INTO verizon ( twitter_id , actor_id , actor_display_name , posted_time , display_name , geo_coords_lat , geo_coords_lon , location_name , posted_day ) VALUES ( '$twitter_id' , '$actor_id' , '$actor_display_name' , '$posted_time' , '$display_name' , '$geo_coords_lat' , '$geo_coords_lon' , '$location_name' , '$posted_day' ) " ; return $qry; notice that you have to "return" the query within your function in order for it to fire when you call it } hide "Parsing of a JSON File..."

The previous examples / content do a pretty good job of getting you up to speed, not just in terms of theory, but also practical application. This next section takes things to a whole new level - yet another "tier" in terms of grouping. Up to this point, you've got:

procedural - line by line retrieval of info...
functions - heavy lifting done up front, "grouping" database functionality so you're not having to put the key in the ignition every time you want to access info from the database. Rather, you write your interaction with the database one time within a function and then retrieve that info with a few lines of code every time you need it, rather than having to write a "select" statement every time.
OOP - grouping functions as classes. Again, just another level of "grouping..."

Now, we're going to look at taking OOP to another level using an "MVC" approach...

IV) MVC Approach

Model, View, Controller is a term used to describe a particular type of approach to software design. You're basically organizing things into three different classifications. You've got...

what is being "processed," this is all of your interactions with your database - this is your "Model"
what is "seen," your GUI - this is your "View"
the "hub" that coordinates everything and brings it together as one, elegant app. This is your "Controlller"

What follows are not just notes, but every shred of code that I put together in order to construct one of the more complicated apps I've built to date. Not so much in terms of "what" was done, but also because of the "way" it was done using this MVC / OOP approach.

By the way, I know this tutorial started out by my expressing my resolve to build an app that would normally be relatively easy using a familiar, procedural approach. This tutorial / journal has been crafted over several months, so suffice to say that the "app" being referred to at the beginning is a ship that has sailed. We're now moving on to far more complicated and elegant territory...! Also, I would be remiss if I didn't give credit where credit is due. The following is an approach authored by John Stokes. While he didn't ask for credit, I did want to reference him as the braintrust behind what you're about to see. If you would like to contact him, holler at me and I'll get you in touch. The following code / app can be seen by clicking here and there's an admin / commentary option that can be viewed by clicking here.

A) Where We're Going - an Intro Let's start with this: Anytime you call a particular function or class, you kick things off by creating an "object." Now, pause for a moment because this rates a bit of a review.

The basic hierachy of OOP is Class >> Object >> Instance. Like this: $bring_it=new Class(); //instantiate the class $bring_it_object=$bring_it->bring_it_function(); //the "$bring_it_object" is the object of my $bring_it class. I'm calling a specific function within that class $bring_it_instance=$bring_it_object(returned result of object) //the specific result of the function represented by the $bring_it_object With this "MVC" approach to PHP / OOP, we visualize the page itself as the "object" of a particular class. In other words, the presence of a page instantiates a Class or, in this case, several classes.

So, let's say I've got your basic "index.php" page. How's that going to look? Like this:
/* CONTROLLER - csv_upload.php */ require_once('userpageclass.php'); require_once('csvClass.php'); require_once('user_uploadView.php'); $new_page= new AdminPage; $new_page->setBody($body); echo $new_page->display(); Tell me that doesn't look good! Basically, you've got 5-6 lines of code that simply "call" different classes and functions categorized under either the "View" or "Model" headings and you're orchestrating all of that in the context of your actual page, which is your "Controller." And what's great about all this is by keeping your functionality and your aesthetics separate, you've added yet another layer of organization that makes edits and even entire GUI overhauls very easy to faciliate! Let's take a look at what constitutes the "Controller" classes of this infrastructure... B) The Controller This is a repeat of what we just discussed, but since it's a little more involved, it's worth repeating, especially given some of the additional functionality that's present.

<?php
require_once('adminpageclass.php');
require_once('csv_AdminClass.php');
require_once('csv_AdminView.php');
$new_page= new AdminPage;
$new_tool = new ToolAdmin;
$tool_list=$new_tool->tool_list();
$body = '<br><br><div style="float:right;"><select name="select62" size="1" onchange="MM_jumpMenu(\'new\',this,1)">
<option value="#" selected>Tools</option>';
$tool_rows=tool_select($tool_list);
$body .=$tool_rows;
$body.='
<option value="">_______________________________</option>
</select></div>Every time you upload a CSV file into a
reporting tool, there\'s always a chance that some of your naming conventions don\'t match the
field names of the database you\'re getting ready to interact with. To avoid that, this tool
gives you the opportunity to "connect the dots" between your field names and the field names of
the appropriate database. <br><br>At the end of the process,
you\'ll have the opportunity to store your preferences so you won\'t have to do this every time
you want to use a particular tool. Start by selecting the tool you want to use from the
pulldown to the right.<br><br>To download a sample CSV file to see this
app in action, click <A
HREF="http://cascsapws1v.nss.vzwnet.com/sandbox/atlanta.csv" target="_blank">here</a>. Also, the list of tools that you see
displayed in the pulldown menu to the right can be edited using the admin suite which can be accessed
by clicking <a href="adm/admin.php"
target="_blank">here</a>.<br><br>
';
$new_page->setBody($body);
Every time you upload a CSV file into a reporting tool, there\'s always a chance that some of your naming conventions don\'t
echo $new_page->display();
?>

In this instance, I chose to put some of the text within the "Controller" dynamic. Generally, you put most of your "aesthetics" in your "View." Now, let's break it down: You've got "adminpageclass.php" on line two. This is an extension of the "htmlpage.class.php" page where you've got your basic HTML documented including your doctype, where you stylesheet is located that kind of stuff. Take a look:

<?php
session_start();
//if the user has opted to use a preference they've documented previously, their session_id is going to be their email address
if(empty($the_session_id))
{
if(isset($_POST['email_preference'])&& trim(!$_POST['email_preference']==""))
{
$the_session_id=trim($_POST['email_preference']);
}
elseif (isset($_GET['preference'])&& !$_GET['preference']=="")
{
$the_session_id=trim($_GET['preference']);
}
else
{
$the_session_id=session_id();
}
}
//echo $the_session_id;
require_once ('htmlclass.php');
class AdminPage extends htmlpage
{
const ROOTURL = 'http://www.brucegust.com/OOP/csv_upload';
//BASE URL for all pages
public function __construct($title='CSV Upload Station')
{
parent::__construct($title);
$this->setMetaTags('<meta http-equiv="X-UA-Compatible" content="IE=9" />
<meta name="description" content="website description" />
<meta name="keywords" content="website keywords, website keywords" />
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
');
$this->headerBottom ='
<map name="right_tabs">
<area shape="rect" coords="372,7,459,29" href="http://www.brucegust.com/" target="_blank">
<area shape="rect" coords="475,7,553,29" href="http://www.brucegust.com/portfolio/sample_code/" target="_blank">
<area shape="rect" coords="567,7,642,29" href="http://www.brucegust.com/campaign/OOP/" target="_blank">
<area shape="rect" coords="658,7,732,29" href="http://www.brucegust.com/campaign/portfolio.php" target="_blank">
</map>
<div id="header">
<div id="logo"></div>
<div id="right_tabs"><img src="http://brucegust.com/campaign/OOP/csv_upload/images/right_tabs.jpg" usemap="#right_tabs" border="0"></div>
</div>
<script>
$(document).ready(function() {
<link href="js/jquery-ui-1.10.4.custom/css/blitzer/jquery-ui-1.10.4.custom.css" rel="stylesheet">
});
</script>
<style>
td.grey {
background-color:#cccccc;
text-align:center;
font-weight:bold;
}
</style>
</div>
<div id="site_content"><br><br><h3 align="left" style="float:left;">CSV Upload Station Page</h3><div style="float:right;">'.$this->getNavBar().'</div><br><br>
';
$this->footer = '
</div>
<footer>
</footer>
</body>
</html>';
$this->scripts='
<script language="JavaScript"><!--
function MM_jumpMenu(targ,selObj,restore){ //v3.0
window.open(selObj.options[selObj.selectedIndex].value, "_self");
if (restore) selObj.selectedIndex=0;
}
</script>
';
}
protected function getSubnav()
{
$subnav='';
return $subnav;
}
public function webAddress()
{
$this->web_address=substr($_SERVER["SCRIPT_NAME"],strrpos($_SERVER["SCRIPT_NAME"],"/")+1);
return $this->web_address;
}
protected function getNavBar ()
{
$nav_bar ='
<a href="index.php">Home</a> | <a href="login.php">Login</a>
';
return $nav_bar;
}
public function logout()
{
session_start();
session_destroy();
}
}
?>

The biggest distinctive factor about "adminpageclass" is the addition of the security measure you see at line 5. Beyond that, it's pretty intuitive. The "csv_AdminClass.php" page is where you see all of your functionality in terms of selecting, inserting and editing data. This is your "Model" and you can see that broken down with some comments by clicking on the link below. C) The Model Again, the "Model" is where you're storing all of your database functionality. This is a great way to keep your aesthetics separate from your functionality. view csv_AdminClass.php page

<?php I didn't include every function on this page, just those that represented some of the more common functions... /*CSV Model - csvClass.php */ ini_set('display_errors', 1); error_reporting(E_ALL); include("carter.inc"); $mysqli = new mysqli($host,$user,$password,$database); if($mysqli->connect_errno) { $err="CONNECT FAIL: " .$mysqli->connect_errno . ' ' .$mysqli->connect_error ; trigger_error($err, E_USER_ERROR); } function csv_display() { global $mysqli; //anytime you're getting ready to grab a bunch of records as opposed to one particular row, you'll use the format you see below in that you're "packing" all of your data into a "$result_array" $sql="select * from twitter_test order by posted_time LIMIT 10"; $query=$mysqli->query($sql); $result_array = array(); while ($row=$query->fetch_array()) { $result_array[]=$row; } return $result_array; } // a basic delete function where you're just deleting one row based on the session_id function delete_csv($session_id) { global $mysqli; $sql="delete from twitter_test where session_id='$session_id'"; $query=$mysqli->query($sql); } function login() { if(isset($_POST['password'])&& !$_POST['password']=="") { if($_POST['password']=="Secret") { $_SESSION['auth']="yes"; header("Location:admin_suite.php"); exit(); } } else { header("Location:admin_wrong_login.php"); exit(); } } //logout funtion - easy...! function logout() { session_destroy(); } class ToolAdmin { public $table_name; public $tool_name; public function __construct() { if(!empty($_POST['table_name'])) { $this->table_name=trim($_POST['table_name']); } if(!empty($_POST['tool_name'])) { $this->tool_name=trim($_POST['tool_name']); } } //check_tool is just looking to see if you have a particular value in a row and returns a count. Usually, you're going to use that count to determine the outcome of an "if" statement public function check_tool() { global $mysqli; $tool_name=$mysqli->real_escape_string($this->tool_name); $sql="select tool_name from tools where tool_name='$tool_name'"; $query=$mysqli->query($sql); $count=$query->num_rows; return $count; } //basic insert statement, grabbing the variables from what's been passed into the function, cleaning them up and then inserting them into the appropriate table public function tool_insert() { global $mysqli; $tool_name = $mysqli->real_escape_string($this->tool_name); $table_name=$mysqli->real_escape_string($this->table_name); $sql = "insert into tools (tool_name, table_name) values ('$tool_name', '$table_name')"; if(!$query=$mysqli->query($sql)) { $err = 'query_failure:' .'ERRNO: ' .$mysqli->errno .' ERROR: ' .$mysqli->error .PHP_EOL .' QUERY:' .$query .PHP_EOL; trigger_error($err, E_USER_WARNING); } } public function tool_list() { global $mysqli; $sql="select * from tools order by tool_name"; if(!$query=$mysqli->query($sql)) { $err ='query_failure:' .'ERRNO: ' .$mysqli->errno .'ERROR:' .$mysqli->error .PHP_EOL .' QUERY:' .$query .PHP_EOL; trigger_error($err, E_USER_WARNING); } $result_array=array(); while($row=$query->fetch_array()) { $result_array[]=$row; } return $result_array; } //I use this a lot as part displaying and / or routing the user to the "delete" page if they selected to delete a particular item. You'll see this at the top of any "display..." page public function edit_redirect() { if(!isset($_GET['Edit'])) { header("location:tool_delete.php?id=$_GET[id]"); exit(); } } //although you can use "fetch_object" for an individual row, you can also use fetch_array public function tool_display() { global $mysqli; $sql="select * from tools where id='$_GET[id]'"; if(!$query=$mysqli->query($sql)) { $err='query_failure:' .'ERRNO: ' .$mysqli->errno .'ERROR:' .$mysqli->error .PHP_EOL .' QUERY: ' .$query .PHP_EOL; trigger_error($err, E_USER_WARNING); } $result_array=array(); while($row=$query->fetch_array()) { $result_array[]=$row; } return $result_array; } //good example of an update query public function update_tool() { global $mysqli; $tool_name = $mysqli->real_escape_string($this->tool_name); $table_name=$mysqli->real_escape_string($this->table_name); $sql="update tools set tool_name='$tool_name', table_name='$table_name' where id='$_POST[id]'"; if(!$query=$mysqli->query($sql)) { $err='query_failure:' .'ERRNO: ' .$mysqli->errno .'ERROR: ' .$mysqli->error .PHP_EOL .' QUERY: ' .$query .PHP_EOL; trigger_error($err, E_USER_WARNING); } } ?> hide csv_AdminClass.php page

D) The View It's here where the "display" of the queries that are documented under the "Model" category is accomplished. Take a look: //a little function that first checks to see if any data is being submitted, the invokes the "check_tool" function to see if a record of the same name already exists. If not, the user is routed to the "tool_insert" function function tool_add() { if(isset($_POST['table_name'])&&!trim($_POST['table_name'])=="" AND (isset ($_POST['tool_name'])&&!trim($_POST['tool_name'])=="" )) { $new_admin= new ToolAdmin; $the_count=$new_admin->check_tool(); if($the_count>0) { header("location:tool_duplicate.php"); exit(); } else { $new_admin->tool_insert(); } } } //probably the most common way of displaying an array that was constructed in the csv_AdminClass.php (Model) page. In this instance, we're grabbing the array that was returned by the method "tool_list" and then displayed using the syntax you see below function tool_array($tool_list) { $briefcase=''; foreach ($tool_list as $tool) { $briefcase .=" {$tool['tool_name']} {$tool['table_name']} edit delete "; } return $briefcase; } Again, this is just some brief commentary in order to better trace the logic of what's going on when you deploy an MVC approach to OOP. For more commentary and a working model of the app, click here.