The PHP Calendar is a class that generates a calendar for a given month and year. Best of all, it is extremely easy to use and can easily be extended to do whatever you want.

Create and Display The Calendar

Creating and displaying the calendar is very easy and can be done with only two lines of code.

1
2

$calendar = new Calendar(1, 2009);
$calendar->generate();

The constructor takes in two variables. The first one for the month, and the second one for the year. The generate() method generates the calendar in an HTML table.

Other Functionality

There are a number of functions in the class that modify the way the calendar renders.

shortMonthTags() – Show the month as three letter abbreviation instead of the entire month name

longMonthTags() – Show the full month name (default functionality)

longDayTags() – Show the days with their full name

shortDayTags() – Show the tags with their single character abbreviations (default functionality)

addDayLink($day, $url) – Makes the $day number link to $url

getNextMonthYear() – Gets the next month relative to the current calendar month and year

getPreviousMonthYear() – Gets the previous month relative to the current calendar month and year

getCurrentMonthYear() – Gets the current month and year (The real time, not the month and year of the current calendar)

setNextMonthContent($string) – Sets the content of the box to the right of the Month and Year. Generally this will be a link to the next month.

setPreviousMonthContent($string) – Sets the content of the box to the left of the Month and Year. Generally this will be a link to the previous month.

set($var, $val) – Universal set function. Set any $var with the value $val.

The Authorize.net Class is used to interact with Authorize.net in order to authorize and capture funds off of a credit card. In order to use the Authorize.net service you have to sign up for an account on at Authorize.net. In order to use this class correctly you have to have the API Login and Transaction Key for your account.

The first thing you have to do to use the class is to set your API Login and Transaction Key into the constant values in the class. You can find these values on lines 23 and 24 of the class. Line 25 is a Boolean value weather you want to use the live server or the development system. By default it is set to the development environment. To move to the live environment simply change the value from false to true.

Create New Authorization

Creating an authorization requests the right to take funds from a credit card at a later point. This is ideal for e-Commerce applications as you are not supposed to take money from the customer until you know you are going to ship the order. Authorizations are generally good for 30 days. After 30 days you can no longer capture funds based on the authorization. In order to create the authorization you call the authorize method of the class with the following paramaters:

$authorizenet = new AuthorizeNetAIM();

$authorizenet->authorize($amount, $cc_number, $cvv, $expire, $first_name, $last_name, $address, $city, $state, $zip, $country);

Variable Description

$amount (required): The dollar amount you want to authorize

$cc_number (required): The credit card number you want to authorize funds against

$cvv (required): The Credit Card Verification Number that is found on the back of most credit cards. This number is usually 3 digits, but is 4 digits for American Express

$expire (required): The expiration date of the credit card. For best results it should be in the format of MMYY or MMYYYY.

$first_name (required): The first name of the card holder

$last_name (required): The last name of the card holder

$address (optional): The street address of the card holder

$city (optional): The city of the card holder

$state (optional): State abbreviation of the card holder

$zip (optional): The zip code of the card holder

$country (optional): The country of the card holder

It should be noted that while many of these paramaters are optional, based on your Authorize.net account it could effect the outcome of your authorization.

Create Authorization and Capture All At Once

This is generally called “Auth Capture” as it creates an authorization and captures the funds immediately. This is best suited for situations where the customer receives their good or services right up front (a brick and morter store, or a consulting services). It works exactly the same as a regular authorization with regards to the paramaters it takes in. Here is the syntax:

$authorizenet = new AuthorizeNetAIM();

$authorizenet->authorize_capture($amount, $cc_number, $cvv, $expire, $first_name, $last_name, $address, $city, $state, $zip, $country);

(See above for description of parameters and if they are required or optional)

Capture Funds

Capture funds is used to actually take money from a credit card based on a previous authorization. Here is the syntax:

$authorizenet = new AuthorizeNetAIM();

$authorizenet->capture($amount, $transaction_id, $authorization_number, $cc_number, $expire);

Variable Description

$amount (required): The amount you want to capture. This value cannot be higher than the amount you requested from the initial authorization

$transaction_id (required): The transaction ID that Authorize.net gave you when you created your initial authorization

$authorization_number (required): The authorization number that Authorize.net gave you when you created your initial authorization

$cc_number (required): The credit card number that you created the initial authorization with

$expire (required): The expiration date of the credit card

Issue Credit

Credit is used to credit funds back onto a credit card. You must have an open authorization on the card to be able to credit funds back to a credit card. You call the function with the following syntax:

$authorizenet = new AuthorizeNetAIM();

$authorizenet->credit($amount, $cc_number, $cc_expire, $trans_id)

Variable Description

$amount (required): The amount of money you want to credit back to the account

$cc_number (required): The credit card number

$cc_expire (required): The credit card expiration number

$trans_id (required): The transaction ID from the initial authorization

Void Authorization

Void authorization is used when you no longer want to interact with Authorize.net using a specific authorization. This would be used if a customer cancels their order. To void an authorization use the following syntax:

$authorizenet = new AuthorizeNetAIM();

$authorizenet->void_authorization($trans_id);

Variable Description

$trans_id (required): The transaction ID from the original authorization

Function Response

Each one of the methods of this class return a specifically designed array that will give you all the information for the results. When running the functons simply do a print_r on the result to see the results. Here are the results that come back from Authorize.net

response_code, response_subcode, ‘response_reason_code, response_reason_text, authorization_code, avs_response, transaction_id, invoice_number, description, amount, method, transaction_type, customer_id, first_name, last_name, company

If you have any questions please post a comment or contact me.

What is Ajax?

Ajax is a way to call back to the webserver without refreshing the entire page. This is done through Javascript. There is a very lengthy discussion I could have with you about this, but there are better resources out there about how it actually works. All you really need to know is that you can use it to call back to the webserver to do whatever you want to. It can be used to add an item to a shopping cart or update a certain part of the page to streamline a process.

On To The Code

I am going to assume you know how the calendar object works. If not please read the PHP Calendar Instructions Page.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

<?
// Import the PHP Calendar Object
require_once('object.calendar.php');
if( isset($_REQUEST['action']) ) {
	switch( $_REQUEST['action'] ) {
		case 'ajax_generate': {
			$month = $_REQUEST['month'];
			$year = $_REQUEST['year'];
			$calendar = new Calendar($month, $year);
			$next_month = $calendar->getNextMonthYear();
			$previous_month = $calendar->getPreviousMonthYear();
			$calendar->setNextMonthContent('<a href="javascript:ajaxChangeCalendar('.$next_month['month'].', '.$next_month['year'].')"> > </a>');
			$calendar->setPreviousMonthContent('<a href="javascript:ajaxChangeCalendar('.$previous_month['month'].', '.$previous_month['year'].')"> < </a>');
			$calendar->generate();
			exit();
		} break;
	}
}
?>
<html>
<head>
	<script type="text/javascript" src="jquery.js"></script>
</head>
 
<body>
 
	<div id="calendar_group">
		<?
		$month = 1;
		$year = 2009;
		$calendar = new Calendar($month, $year);
		$next_month = $calendar->getNextMonthYear();
		$previous_month = $calendar->getPreviousMonthYear();
		$calendar->setNextMonthContent('<a href="javascript:ajaxChangeCalendar('.$next_month['month'].', '.$next_month['year'].')"> > </a>');
		$calendar->setPreviousMonthContent('<a href="javascript:ajaxChangeCalendar('.$previous_month['month'].', '.$previous_month['year'].')"> < </a>');
		$calendar->generate();
		?>
	</div>
	<?
	$current_month = $calendar->getCurrentMonthYear();
	?>
	<a href="javascript:ajaxChangeCalendar(<?=$current_month['month']?>, <?=$current_month['year']?>)">Current Month</a>
	<br/><br/>
	<select name="move_to_month" id="move_to_month">
		<?
		for($i=1; $i<=12; $i++) {
			?><option value="<?=$i?>"><?=$i?></option><?
		}
		?>
	</select>
	<select name="move_to_year" id="move_to_year">
		<?
		for($i=1900; $i<=2020; $i++) {
			?><option value="<?=$i?>"><?=$i?></option><?
		}
		?>
	</select>
	<input type="button" value="Go To" onclick="ajaxChangeCalendar( document.getElementById('move_to_month').value, document.getElementById('move_to_year').value )" />
	<script type="text/javascript">
		function ajaxChangeCalendar( month, year ) {
			var redraw = $.ajax({
							type: "POST",
							async: false,
							url: "ajax_calendar.php",
							data: "action=ajax_generate&month=" + month + "&year="+year
						}).responseText;
			$("#calendar_group").html(redraw);
		}
	</script>
</body>
</html>

The first thing I am going to bring your attention to is including the jQuery library on line 22. So as you can see we are generating a calendar on lines 29-36. The Next and Previous Month Content. What we are going to put in there is a link that calls a Javascript function called ajaxChangeCalendar.You will also notice that we call this function on lines 42 and 59. Line 42 moves the calendar to the current month and year, while the button on line 59 uses the values from the dropdown menu to determine where to go.

Now for the meat and potatoes of Ajax, the ajaxChangeCalendar function. You will notice that we are utilizing jQuery’s Ajax functionality. We set the type to Post (It could easily be Get if you wanted to), async is set to false, set the URL and the data that should be put into POST. The $.ajax will do all the work for you. It reaches out and takes the text it received and puts it into the variable redraw.

We then take that text and use replace the HTML in the calendar_group div with the value of redraw.

That seems simple right? It really is. Now let’s talk about how we get the data that goes into redraw. This can be found on lines 4-18. You will notice that it looks exactly the same as the code that generated the calendar initially, except for the fact that the month and possibly year have changed. What is happening is that you are outputting the HTML code that will replace the HTML in the calendar_group div.

Also, notice the exit() being called on line 15. We do not want any more HTML to output after the table. Otherwise you will have the entire page put into the value of redraw and that will in turn redraw the entire page. That would defeat the purpose of Ajax in the first place.

Anyways, I hope this helps to explain how you can use jQuery to put Ajax on your site. This was a very simple example but you can do a whole lot more with Ajax if you put your mind to it. If you have any questions post a comment or submit it in the contact form.

1.  if( $use_live_server ) {
2.    $url = "http://www.thelivesite.com"
3.  } else {
4.    $url = "http://www.thedevsite.com";
5.  }

This block of code sets which URL we want to connect to based on if a variable called $use_live_server.  While the block of code is perfectly valid, there is a much better way to do the exact same thing in a single line of code.

1.  $url = $use_live_server ? "http://www.thelivesite.com" : "http://www.thedevsite.com";

That one line of code does the exact same thing and once you understand how this works.  Here is how the ternary operator works:

$variable = $expression_to_evaulate ? true : false

You do not necessaryly have to have a variable that is true or false.  You can do any expression you need to.

So now that you know about the ternary operator, you can start using it and it will improve the quality of your code.  In the Authorize.net class you will notice this being used on line 41:

$this->transact_url = AUTH_NET_USE_LIVE_API ? "https://secure.authorize.net/gateway/transact.dll" : "https://test.authorize.net/gateway/transact.dll";

This line is setting the URL to connect to for the object based on the constant AUTH_NET_USE_LIVE_API.

If you have any questions about this go ahead and post a comment or contact me.

1. $ch = curl_init($url);
2. curl_setopt($ch, CURLOPT_HEADER, 0);
3. curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
4. curl_setopt($ch, CURLOPT_POSTFIELDS, $fields);
5. $result = curl_exec ($ch);

These 5 lines of code do a lot.  In line 1 you begin creating your transaction by calling curl_init() and passing the URL you want to connect to (in this case we have a variable called $url).

Lines 2-4 set different options for the transaction.  The CURLOPT_HEADER option is set to zero to signify we do not want the header information in the response. CURLOPT_RETURNTRANSFER tells cURL to assign the data we receive to a variable rather than simply output it to the screen.  CURLOPT_POSTFIELDS sets what data we want to send in the header of our request. This is a very important option when interacting with other systems as this is generally where you will put your XML or other header data that is required by the system you are connecting with.

Line 5 actually executes the request.  It will reach out to the $url, with $fields in the POST areas of varaibles and putting the data we received into the variable $result.

You can now process the data in whatever way you need to for your application.  In the Authorize.net class the data gets passed to the parse_response() function to format the data in such a way that we can easily work with it.

If you have any questions about cURL post a comment and I will answer to the best of my ability.  To read more about cURL you can refer to the PHP documentation here.

The first thing you need is to do is choose an environment to create a virtual machine.  For this tutorial I am going to use VMware Server.  Generally I try to use open source software, but VMware is simply the best virtulization software out there.  VMware Server can be downloaded here.  Please note that I am going to use version 1.x, not the newer 2.x.  I find that the 2.x version takes up more resources and does things a little differently than I like.  You can do the 2.x if you like.  It is just my preference.

You now need to determine what OS you want to install.  You can install any OS you want, but this tutorial will cover Ubuntu server.  By default it comes with no GUI which is great since it will take very little system resources.  You can download Ubuntu here.

Creating The Virtual Machine and Installing Linux

Now that you have VMware Server installed and you have your ISO image, you are now ready to create a virtual machine.

Click “New Virtual Machine” and follow the directions in the wizard.

Click New Virtual Machine

Click Next

Typical will do for about 99% of all situations.

This tutorial is going to go through installing Ubuntu Linux so make sure you set the correct OS.

Now we need to determine where we are going to put the VM.  You can put this where ever you want.

I always do bridged networking.  It makes things easier for dealing with IP addresses and the like.

Now determine the size of the VM.  You will want to think ahead on this one as increasing the size of a VM is a pain.  I also unclick the Allocate all disk space now.  They say that it increases performance if it is allocated up front.  I have not had any problems with performance when not allocating all the space.  Finally click finish.

Now you have a virtual machine created.  Now you can run this with the 512 MB of RAM but that is taking into account that a GUI is going to be running full time.  For install I usually like to cut that down to 256 MB to help the install go faster.  After install you can cut it down depending on what you are doing.  For PHP you can easily take it down to 64 MB and Ruby on Rails works better with at least 128 MB.  To adjust the RAM simply double click on the RAM and make the adjustment.

You can leave this value as is or take it down to 256MB.  It is up to you.

Now you have to mount the iso you downloaded from the internet.  Just double click the CD-ROM icon in the main window and click Use ISO image and browse to the file.

Now go ahead and hit the green play button and start up your virtual machine.  I am not going to go into deep details into the install of Ubuntu.  For the most part you will just hit enter and follow the on screen prompts.  Just make sure at the end of the install you have installed the LAMP server and the OpenSSH server.  See you at the end!

Assign A Static IP Address To The Server

Assigning a static IP address to your server makes life a lot easier.  You always know where to go in your web browser to access it.  To do that you have to modify your network interfaces file (I do not know if that is its real name, but that’s what I call it).  The smart thing to do is create a backup of your network interfaces file.  To do that you type the following command:

cp /etc/network/interfaces ~

That will create a copy of the file in your home directory.  To restore the file you type:

sudo cp ~/interfaces /etc/network/interfaces

To edit the file you type the following command:

sudo nano /etc/network/interfaces

Nano is a very simple text editor.  You will have to modify this file to fit your network.  This can be tricky to figure out.  I will gie you the specs for my network and hopefully they will works for you.

Here is what is in my file.

auto lo
iface lo inet loopback

auto eth0
iface eth0 inet static
address 192.168.1.101
netmask 255.255.255.0
network 192.168.0.0
broadcast 192.168.1.255
gateway 192.168.1.1

Now I wish I could give you a rhyme or reason for those numbers.  My routers IP address is 192.168.1.1.  The rest of the numbers I basically stumbled upon by looking at a known good configuration.  The netmask should be in your router config panel.  The address is the IP address you want the VM to have.  Network and Broadcast are the tricky ones.  Hopefully this works for you.

Install Webmin

Now that you have Ubuntu installed and on a static IP you will probably want to have a way to manage everything on the server.  Since there is no GUI on the server you will want to have a graphical way to mange some aspects of the server.  Luckily there is webmin.  It is a web based solution to allow you to manage your server.  To get Webmin you have to download it directly from their site.  To do that login to your Virtual Machine and enter the following command:

wget http://prdownloads.sourceforge.net/webadmin/webmin_1.441_all.deb

This will download the current (as of this writing) version of Webmin.  Now you have to install the package.  You can do that by typing:

sudo dpkg -i webmin_1.441_all.deb

If you get any messages saying that you are missing some libraries enter the following command after the installiation is complete:

sudo apt- get install -f

That will resolve any issues with missing libraries.

Now you can go to any machine on your network and type https://<ip_address>:10000 and you will get Webmin.

Just enter your username and password to login.  Very simple!

You will notice that this thing is ugly!  I had a hard time using it because its layout is not ideal.  Luckily there is a way to fix that.

Click Webmin in the upper left corner then Webmin Configuration.  Then click the icon Webmin Themes.

We are going to install a theme that is based on OSX Tiger.  It is the most user friendly theme I have seen. To isntall it you click the radio button From ftp or http URL and enter “http://www.stress-free.co.nz/files/theme-stressfree.tar.gz” into the text box and hit Install Theme.  After the install is done it might look a little odd and maybe show an error.  All you have to do is go back to the root URL of Webmin and you should be fine.

Now you have a nice easy to manage server.

FTP Server

You have just about everything you need to do development on your server except one thing.  FTP.  Luckily now that we have Webmin installed we can do that in a snap.  At the top you will see Servers.  Hover your mouse and see the popup menu.  Go down until you see ProFTPD Server and click on that.  You will see a message saying that it is not installed, but they can do that for you.  Simply click on the link and watch Webmin do all the heavy lifting for you!  You can now connect to your server via FTP which will make development on your server a snap!

Conclusion

This should give you a good start on a development server.  Go ahead and play around in Webmin.  It really makes things a lot easier for you.  If you have any questions or comments or suggestions leave a comment below.