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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275

/**
 * 
 *  @author Wojciech Gancarczyk <gancarczyk@gmail.com>
 */
class App_Analytics_Helper
{
    const CLIENTLOGIN_URL = 'https://www.google.com/accounts/ClientLogin';
    const ACCOUNT_FEED_URL = 'http://www.google.com/analytics/feeds/accounts/default';
    const DATA_FEED_URL = 'https://www.google.com/analytics/feeds/data';
    const SERVICE_NAME = 'analytics';
 
    /**
     * @var string
     */
    protected $_auth;
 
    /**
     * @var string
     */
    protected $_applicationName = 'MyApp-MyDesc-0.1';
 
    /**
     * @var string
     */
    protected $_username;
 
    /**
     * @var string
     */
    protected $_password;
 
    /**
     * @var int
     */
    protected $_ga;
 
    /**
     * Class counstructor. It accepts only array as a parameter. It then
     * checks, if the array keys correspond to the setters of this class
     * and if they do, it sets them. After that it is trying to perform
     * authentication.
     *
     * @param array $params
     * @throws Exception
     */
    public function __construct($params = array())
    {
        if (!is_array($params))
            throw new Exception(
                'Constructor accepts only an array as a parameter');
 
        if (!empty($params)) {
            $methods = get_class_methods($this);
 
            foreach ($params as $key => $value) {
                $method = 'set' . ucfirst($key);
                if (in_array($method, $methods))
                    $this->$method($value);
            }
            $this->authenticate();
        }
    }
 
    /**
     * Performs authentication. It has to be calles before any data
     * can be received, because auth is neccassary for each call.
     *
     * @param string $username
     * @param string $password
     * @throws Exception
     */
    public function authenticate($username = null, $password = null)
    {
        if (null === $username && null === $this->getUsername())
            throw new Exception(
                'Username is necessary to perform authentication');
 
        if (null === $password && null === $this->getPassword())
            throw new Exception(
                'Password is necessary to perform authentication');
 
        if (is_string($username))
            $this->setUsername($username);
 
        if (is_string($password))
            $this->setPassword($password);
 
        $client = new Zend_Http_Client(self::CLIENTLOGIN_URL);
        $client->setMethod(Zend_Http_Client::POST);
 
        $client->setParameterPost(array(
		'Email'       => $this->getUsername(),
		'Passwd'      => $this->getPassword(),
                'AccountType' => 'GOOGLE',
                'service'     => self::SERVICE_NAME,
                'source'      => $this->getApplicationName(),
        ));
        $response = $client->request('POST');
 
        if ($response->getStatus() != '200')
            throw new Exception(
                'Authentication failed. Status returned: ' .
                $response->getStatus());
 
        $return = explode('=', $response->getBody());
        $this->setAuth($return[3]);
    }
 
    /**
     * Recieves the account feed.
     *
     * @return string XML stream
     * @throws Exception
     */
    public function getAccountFeed()
    {
        if (null === $this->getAuth())
            throw new Exception(
                'Account Feed cannot retrieve any results, ' .
                'because the client was not authenticated');
 
        $client = new Zend_Http_Client(self::ACCOUNT_FEED_URL);
        $client->setMethod(Zend_Http_Client::GET);
        $client->setParameterGet('start-index', '1');
        $client->setParameterGet('max-results', '2');
        $client->setParameterGet('prettyprint', 'true');
        $client->setHeaders('Authorization', 'GoogleLogin auth=' . $this->getAuth());
        $response = $client->request('GET');
 
        if ($response->getStatus() != '200')
            throw new Exception(
                'Authentication failed. Status returned: ' .
                $response->getStatus());
 
        return $response->getBody();
    }
 
    /**
     * Performs data feed.
     *
     * @return string XML stream
     * @throws Exception
     */
    public function getDataFeed()
    {
        if (null === $this->getAuth())
            throw new Exception(
                'Account Feed cannot retrieve any results, ' .
                'because the client was not authenticated');
 
        if (null === $this->getGa())
            throw new Exception(
                'Account ID was not provided');
 
        $client = new Zend_Http_Client(self::DATA_FEED_URL);
        $client->setMethod(Zend_Http_Client::GET);
        $client->setParameterGet('ids', 'ga:' . $this->getGa());
        $client->setParameterGet('dimensions', 'ga:source,ga:medium');
        $client->setParameterGet('metrics', 'ga:visits,ga:bounces');
        $client->setParameterGet('sort', '-ga:visits');
        $client->setParameterGet('start-date', '2009-08-01');
        $client->setParameterGet('end-date', '2009-08-31');
        $client->setParameterGet('start-index', '10');
        $client->setParameterGet('max-results', '100');
        $client->setHeaders('Authorization', 'GoogleLogin auth=' . $this->getAuth());
        $response = $client->request('GET');
 
        if ($response->getStatus() != '200')
            throw new Exception(
                'Authentication failed. Status returned: ' .
                $response->getStatus());
 
        return $response->getBody();
    }
 
    /**
     * Setter for username.
     *
     * @param string $username
     */
    public function setUsername($username)
    {
        $this->_username = (string) $username;
    }
 
    /**
     * Getter for username.
     *
     * @return string
     */
    public function getUsername()
    {
        return $this->_username;
    }
 
    /**
     * Setter for password.
     *
     * @param string $password
     */
    public function setPassword($password)
    {
        $this->_password = (string) $password;
    }
 
    /**
     * Getter for password.
     *
     * @return string
     */
    public function getPassword()
    {
        return $this->_password;
    }
 
    /**
     * Setter for auth.
     *
     * @param string $auth
     */
    public function setAuth($auth)
    {
        $this->_auth = (string) $auth;
    }
 
    /**
     * Getter for getAuth.
     *
     * @return string
     */
    public function getAuth()
    {
        return $this->_auth;
    }
 
    /**
     * Setter for applicationName.
     *
     * @param string applicationName
     */
    public function setApplicationName($name)
    {
        $this->_applicationName = (string) $name;
    }
 
    /**
     * Getter for applicationName.
     *
     * @return string
     */
    public function getApplicationName()
    {
        return $this->_applicationName;
    }
 
    /**
     * Setter for ga.
     *
     * @param integer $ga
     */
    public function setGa($ga)
    {
        $this->_ga = (int) $ga;
    }
 
    /**
     * Getter for ga.
     *
     * @return integer
     */
    public function getGa()
    {
        return $this->_ga;
    }
}

As you can see this class is not perfect yet. It basically utilizes Zend_Http_Client and its methods to perform the request and retrieve the results. First of all it needs a better support for setting the parameters to retrieve data and account feeds. Right now they are just hard coded and you cannot influence their values. Besides that as a return value it returns the XML stream. Zend Framework comes with an awesome library Zend_Dom which can be used to read the values from the response. I will definitely put that in this class, but it is a good subject for a next post. You may also consider using it as a controller helper, but then you will need to rewrite it a little bit. It might be another interesting subject for a post.

One more thing left mentioning is the usage of this class. Well, there are two ways of using it. You can either create an array of parameters and pass it while you instantiating this class:

$params = array(
    'username' => 'yourUserName',
    'password' => 'yourPassword',
    'ga' => 'accountId'
);
$analytics = new App_Analytics_Helper($params);
$dataFeed = $analytics->getDataFeed();
$accountFeed = $analytics->getAccountFeed();

You can also use the setters and perform authentication "manually":

$analytics = new App_Analytics_Helper();
$analytics->setUsername('yourUserName');
$analytics->setPassword('yourPassword');
$analytics->setGa('accountId');
$analytics->authenticate();
$dataFeed = $analytics->getDataFeed();
$accountFeed = $analytics->getAccountFeed();

I'm waiting for your comments about this class. I hope it will save you some time.

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
72
73
74
75
76
77
78
79
80
81

/**
 * @author Wojciech Gancarczyk
 */
class MyApp_Mail_Example
{
    /**
     * @var Zend_Mail_Protocol_Smtp_Auth_Login
     */
    protected $_connection;
 
    /**
     * @var Zend_Mail_Transport_Smtp
     */
    protected $_transport;
 
    /**
     * @var string
     */
    protected $_host;
 
    public function __construct()
    {
        $this->_host = 'foo.bar.baz';
        $port = 25;
        $params = array(
            'username' => 'username',
            'password' => 'password'
        );
        $this->_connection =
            new Zend_Mail_Protocol_Smtp_Auth_Login($this->_host, $port, $params);
        $this->_connection->connect();
        $this->_connection->helo($this->_host);
        $this->_transport = new Zend_Mail_Transport_Smtp();
        $this->_transport->setConnection($this->_connection);
    }
 
    /**
     * Get the connection.
     *
     * @return Zend_Mail_Protocol_Smtp_Auth_Login
     */
    public function getConnection()
    {
        return $this->_connection;
    }
 
    /**
     * Get the transport.
     *
     * @return Zend_Mail_Transport_Smtp
     */
    public function getTransport()
    {
        return $this->_transport;
    }
 
    /**
     * Get the host.
     *
     * @return string
     */
    public function getHost()
    {
        return $this->_host;
    }
 
    /**
     * Send the emial
     */
    public function send()
    {
        $mail = new Zend_Mail();
        $mail->addTo('foo@bar.baz, 'Foo Bar');
        $mail->setFrom('foo@bar.baz', 'Foo Bar');
        $mail->setSubject(
            'Demonstration - Sending Multiple Mails per SMTP Connection'
        );
        $mail->setBodyText('...Your message here...');
        $mail->send($this->getTransport());
    }
}

That's it. Of course, you can break it into smaller units of code, resolve the dependencies etc. I just wanted to demonstrate the basics of operation. Class constructor demonstrates mostly, what you need to do to get it work. Basically you need to initialize Zend_Mail_Protocol_Smtp_Auth_Login by passing the host name, port and credentials. After that you connect to your mail server and initiate helo/ehlo sequence which marks the session as valid. After that you need to initialize Zend_Mail_Transport_Smtp and set the connection. The parameter you pass to setConnection method has to be an instance of Zend_Mail_Protocol_Abstract. After performing this initialization you are ready to send the emails. I put an example method send() to demonstrate how to do that. Don't forget to change the credentials, host name and all the emails in the send method. I'm waiting for your feedback, how to improve that.

As I already mentioned in my previous post, to measure the distance between two points on a sphere one can use Haversine formula. For a detailed description I suggest visiting the wikipedia site. In our example we will use a simplified version of Haversine formula, which is caused by a really simple reason. Executing a web query with the actual Haversine formula might lead to a really slow response from the database and our simplified version will retrieve results which do not differentiate that much with the original version.

For retrieving the company branches in a certain radius we will first build a php class, which will be responsible for translating the zip code into geographical lengths and then use this values to retrieve the results and return them as json_encoded() data. Because our class will be relatively long, I will split it into parts and explain it line by line.

Since we are using an AJAX request to retrieve our data and the location of our php file is easy to guess just by looking at our jQuery code (will come after php class), we add a simple check of the apache environmental variable to check, if it actually is an XMLHttpRequest. A lot of you will probably say that this security measure is not enough, but for this example, it will at least stop all the robots trying access this file and since looking up addresses might consume a lot of resources of your server, this will save you some speed lost on servers with high traffic.

1
2

if ($_SERVER["HTTP_X_REQUESTED_WITH"] != 'XMLHttpRequest')
  die('why are you doing this??');

In line 3 we create our class. Since the subject of this example is finding company branches, lets call it Branch. In lines 5 to 13, we define some variables, which we will use in our class. I think they are pretty much self explanatory, and you will understand, what is their usage just by looking at the rest of the class.

3
4
5
6
7
8
9
10
11
12
13

class Branches {
 
  private static $_key = 'YOUR GOOGLE MAPS KEY';
  private static $_host = 'localhost';
  private static $_db_user = 'root';
  private static $_db_pass = 'pass';
  private static $_db_name = 'db';
 
  private $zip, $radius, $data_set;
 
  public $results = array();

In our constructor we connect to the database and set the radius and zip properties. You could notice that I convert the zip property to integer as well and I additionally add leading zero for strings, which length equals 4. Well, this class was written for German zip codes. You might want to change this parts so it suits your needs. After all it will be important in the part where we will convert the zip code to geographical length, so Google can find this zip code in their database.

14
15
16
17
18
19
20
21
22
23
24
25

public function __construct()
{
  $sql = mysql_connect(self::$_host, self::$_db_user, self::$_db_pass) or die(mysql_error());
  mysql_select_db(self::$_db_name, $sql) or die(mysql_error());
 
  $this->radius = (int)$_GET['radius'];
  $this->zip = (int)$_GET['zip'];
 
  // add leading zeros in case of 0... zip codes
  if (strlen($this->zip) == 4)
    $this->zip = sprintf("%05s", $this->zip);  
}

In line 26 we define a public method translateZipToLatLng() and in line 39 a private method getGeolocation(), which both will be responsible for translating the zip code into the geographical length. To get a detailed description, what this two methods actually do, refer to my other post: Geolocation class - retrieving longitude and latitude using google maps.

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

public function translateZipToLatLng()
{
  $url = 'http://maps.google.com/maps/geo?q=' . urlencode($this->zip . ', Germany') . '&output=csv&key=' . self::$_key;
 
  $response = $this->getGeolocation($url);
 
  if (substr($response, 0, 3) === '200') {
    $geo = explode(',', $response);
    return $data = array($geo[2], $geo[3]);
  }
  return false;
}
 
private function getGeolocation($url)
{
  $init = curl_init();
  curl_setopt($init, CURLOPT_URL, $url);
  curl_setopt($init, CURLOPT_HEADER,0);
  curl_setopt($init, CURLOPT_USERAGENT, $_SERVER["HTTP_USER_AGENT"]);
  curl_setopt($init, CURLOPT_RETURNTRANSFER, 1);
  $response = curl_exec($init);
  curl_close($init);
 
  return $response;
}

In line 51 we define a private method getResults, which, as you can see, will be responsible for retrieving all the information from the “branches" table and additionally measure the approximate distance from the zip code provided by the user to our actual company branches. In line 56 we define private method populate results, which will be responsible for creating an array of the results retrieved from the database. As you can see, if our query returns zero rows we define an error, if our query returns at least one row, we create an array with all the information about the company. The last public method in line 75, findBranches() will be the one, which we will call after instantiating our class and translating zip code into geographical length.

51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

private function getResults($latlng)
{
  return mysql_query("SELECT *, (POW((69.1*(longitude-{$latlng[1]})*COS({$latlng[0]}/57.3)), '2') + POW((69.1*(latitude-{$latlng[0]})), '2')) AS distance FROM branches HAVING distance < {$this->radius} ORDER BY distance ASC;");
}
 
private function populateResults()
{
  if (!mysql_num_rows($this->data_set)) {
    $this->results = array(array('error' => 'none'));
  } else {
    while ($row = mysql_fetch_assoc($this->data_set)) {
      $this->results[] = array(
        'name'      => utf8_encode($row['name']),
        'zip'       => $row['zip'],
        'city'      => utf8_encode($row['city']),
        'latitude'  => $row['latitude'],
        'longitude' => $row['longitude'],
        'distance'  => round(sqrt($row['distance']),1),
      );
    }
  }
  return $this->results;
}
 
public function findBranches($latlng)
{
  $this->data_set = $this->getResults($latlng);
  return $this->populateResults();
}

Our class for retrieving results is done. For the simplicity I did not assume the case, when the database query returns zero rows, in which radius should be automatically extended. You can easily do this, by writing one more method, which will be responsible for extending the radius and adding a simple if...else check in our findBranches() method, to make it loop until your query returns any results. As I said before though, in a database with many entries, executing a web query with a formula complicated like the one we are using, retrieving results might consume a lot of time, and creating a loop, in which you will repeat the same query might lead to a really long time a user will have to wait for a response. In my case, the database was a little bit over 1000 entries and extending the radius and repeating the query did not result in any remarkable performance lost though.

The last part is the actual usage of the class we just wrote. Basically in line 84 we instantiate our class, in line 85 we translate the zip code to geographical length and according to the value returned by this method we use json_encode() function to return the results as a json representation of the array we just created or an error.

84
85

$branches = new Branches();
echo ($latlng = $branches->translateZipToLatLng()) ? json_encode($branches->findBranches($latlng)) : json_encode(array('error' => 'zip_invalid'));

Since our class for retrieving the results in a certain radius is ready, we should move to our client side code.

To make this simple, I will just show you the whole jQuery code and discuss it line by line.

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

$(document).ready(function() {  
  var mapContainer = $('#map')[0];
  if (GBrowserIsCompatible()) {
    if (mapContainer) {
      var map = new GMap2(mapContainer);
      map.addControl(new GLargeMapControl);
      map.setCenter(new GLatLng(52.519015140666,13.419671058654785), 14);
 
      $('#submit').click(function() {
        var zip = $('#zip').val();
        var radius = $('#radius').val();
        if (zip == '') {
          alert("You need to provide a zip code");
          return;
        }
        var rand = new Date().getTime();
        $.getJSON('zip.php?rand=' + rand, { zip: zip, radius: radius }, function(data) {
          var markers = [];
          var descriptions = [];
          var bounds = new GLatLngBounds();
 
          map.clearOverlays();
          $('#error').html('');
          $('#locations').html('');
          $('#closest_location').html('');
          var flag = true;
 
          $.each(data, function(i, item) {
            if (item.error == 'none') {
              alert('No results found or ZIP incorrect');
              $('#error').append('No results found or ZIP incorrect');
              flag = false
              return false;
            }
            var description =
              '<div class="branch" style="float: left;">' +
              item.name + ' (~ ' + item.distance + ' km)<br />' +
              item.zip + ' ' + item.city + '<br />' +
              '<span class="branch_show" style="cursor: pointer; color: blue; text-decoration: underline;" id="' + i + '">Show</span></div>';
            var lat = item.latitude;
            var lng = item.longitude;
            var point = new GLatLng(lat, lng);
            var marker = new GMarker(point);
            markers[i] = marker;
            descriptions[i] = description;
            $('#locations').append(description);
            map.addOverlay(marker);
            bounds.extend(point);
            GEvent.addListener(marker, 'click', function() {
              marker.openInfoWindowHtml(description);
            });
          });
 
          $('#closest_location').append(descriptions[0]);
 
          map.setZoom(map.getBoundsZoomLevel(bounds));
          // just in case we did not find anything
          if (!flag)
            map.setCenter(new GLatLng(51.08282186160976,10.26123046875),6);
          else
            map.setCenter(bounds.getCenter());
 
          $('.branch_show').click(function() {
            var id = $(this).attr('id');
            markers[id].openInfoWindowHtml(descriptions[id]);
          });
        });
      });
    }
  }
});

As usually we want to execute the code on onLoad of our document and we do that in line 1. In line 2 we define our container for the map and in line 3 and 4 we check if browser is compatible and if container was found respectively.

In line 5 we instantiate the Gmap2 inside of our map container, we add some controls in line 6 and set the center in line 7. In line 9 we add a event listener which triggers after a user clicks submit button.

In lines 10 to 15 we add a simple check, if the field with the zip code is not empty and it if is we alert an according message and we break the execution of the code. Additionally we define a zip variable in line 10 and radius variable in line 11, which will hold according information to use in our json request.

In line 16 we define rand variable which we pass during our json request to prevent internet explorer to cache the resource. If we would not do that, and changes you would do to zip.php file would not be visible, because IE would use the cached version of this file.

In line 17 we make a request to the zip.php file, which we wrote earlier and we pass the zip code and the radius to our php file. After the calculation is done and you do not have any errors in your php file we retrieve the information, which we can finally process.

In line 18 and 19 we define two variables as arrays, which will be responsible for holding the information about markers and their corresponding descriptions and in line 20 we instantiate GLatLngBounds object, which we will later use to display the information on our map with matching zoom level.

In line 22 to 26 we remove all markers and we empty all containers holding the information about the places from a previous request. We do that to prevent displaying of the same markers after a user requests the zip.php file again. This way, if a user changes his or hers query, we will be sure that we are displaying only the information relevant to the current request and we wont have any trash from the previous requests. In line 26 we define a flag as boolean to use it later to display error information and redisplay the center of the map.

In line 28 we loop through the information we received in response. If an error was found, we break our loop and we display and alert according information to the user. We also set the flag to false to redisplay center of the map later in the code. This would be lines 29 to 34.

In lines 35 to 39 we put together the HTML code which we will use to display the information about the branches we are going to display on the map.

In lines 40 to 43 we define two variables lat and lng and use them to instantiate GLatLng object which we define as point variable. In line 44 we define marker variable as an instance of GMarker object and in lines 45 and 46 we add it to the arrays we defined earlier. In line 47 we append the description to the container we need to define in our HTML and in line 47 we add markers to the map. In line 48 we extend the bounds of our map by using a method extend() of GLatLngBounds object we defined earlier. This amazing functionality of google maps will let us display a square with all our markers and google map will take care of setting the correct zoom level.

In lines 49 to 51 we add a listener which will be triggered on a click event and will display the description in an info cloud. In line 52 we close the loop and in line 54 we append the first description to the closest_location container. To assure that the first description is really the closest place to the zip code provided by the user, you cannot forget about putting the “ORDER BY distance ASC” in the php code of zip.php file.

In line 56 we set the zoom of our map using our bound object I was mentioning before by utilizing getBoundsZoomLevel method of GMap. As you can see in the description in line 57, if our php code did not return any results, we override the zoom level we defined in line 56 be setting it again to the default value (line 59). On the other hand, if our php code returned any results we set the center of the map using our bounds object again (line 61).

The last part of this code is just a listener which is triggered when a user clicks on the pseudo link show. We retrieve the id of this link and display the according info window on the map.

That would be it. The code is done. I know it is not perfect and accurate either. You can still use it in many different ways. It does not necessarily need to be a zip code search. Using it you can display distances between users and any other stuff connected with distances. In the second part I will show you how you can make this code a little bit more accurate using google maps build in api to show the directions, how to get from the zip code provided by the user to one of the company branches.

If you do not want to copy all the code, here is a zip package for you with working files.

To see, how our final solution will look like, go here

1. Geo Class - Geo.class.php

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

class Geo
{
 
    private $xml;
 
    protected function _init()
    {
        $this->xml = simplexml_load_file('geo.xml', 'SimpleXMLElement');
    }
 
    public function getDropDown($id, $option = array())
    {
        $this->_init();
 
        $select = '<select name="' . $id . '" id="' . $id . '">';
 
        if ($option['include_custom'] != '')
            $select.= '<option value="" selected="selected">' . $option['include_custom'] . '</option>';
 
        foreach ($this->xml->children() as $child) {
            $select.= '<option value="' . $child->name . '">' . $child->name . '</option>';
        }
 
        $select.= '</select>';
 
        return $select;
    }
 
    public function getLocation($identifier)
    {
        $this->_init();
 
        $coordinates = array();
 
        foreach ($this->xml->children() as $child)
            if ($child->name == $identifier) {
                $temp = explode(',', $child->Point->coordinates);
                $coordinates = array(
                                    'lat' => $temp[0],
                                    'lng' => $temp[1]
                );
            }
 
        return $coordinates;
    }
}

It wasn't really necessary to put this functions into a class, but it is just a habit We define a protected function _init(), which we call every time we want to use our KML file to retrieve information out of it. The function simplexml_load_file initializes an SimpleXMLElement object for us, which we can use later. The function getDropDown with the first mandatory argument and the second optional will be responsible for displaying the drop down field for us. I think I don't need to explain it in detail. The last function getLocation will retrieve the latitude and longitude from KML file. So let's move to index.php file, which will be the core of this example.

2. Core file - index.php

1
2

include('Geo.class.php');
$geo = new Geo();

Before we send any headers we include our Geo.class.php file and initialize our Geo class. After that goes the usual tag tags and the google maps and jQuery scripts. In the section of our document goes the actual jQuery part.

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

$(document).ready(function() {  
  var mapContainer = $('#map')[0];
  var markerStart;
  var markerEnd;
  if(GBrowserIsCompatible()) {    
    if(mapContainer) {
      var map = new GMap2(mapContainer);
      map.addControl(new GLargeMapControl);  
      map.setCenter(new GLatLng(52.519015140666,13.419671058654785), 14);
 
      $('#start').change(function() {
        var location = $(this).val();
 
        if (location == '')
          return;
 
        $.getJSON('helper.php', { location: location }, function(data) {
          if (markerStart)
            map.removeOverlay(markerStart);
 
          pointA = new GLatLng(data.lat, data.lng);
          markerStart = new GMarker(pointA);
          map.addOverlay(markerStart);
        });
      });
 
      $('#end').change(function() {
        var location = $(this).val();
 
        if (location == '')
          return;
 
        $.getJSON('helper.php', { location: location }, function(data) {
          if (markerEnd)
            map.removeOverlay(markerEnd);
 
          var blueIcon = new GIcon(G_DEFAULT_ICON);
          blueIcon.image = "http://gmaps-samples.googlecode.com/svn/trunk/markers/blue/blank.png";
          var markerEndOptions = { icon: blueIcon };
 
          pointB = new GLatLng(data.lat, data.lng);
          markerEnd = new GMarker(pointB, markerEndOptions);
          map.addOverlay(markerEnd);
        });
      });
 
      $('#submit').click(function() {
        if (window.pointA === undefined || window.pointB === undefined) {
          alert("You need to choose start and end");
          return;
        }
 
        var directions = new GDirections(map);
        route = Array(pointA, pointB);
 
        GEvent.addListener(directions, 'load', function() {
          var dist = directions.getDistance().html;
          $('#distance').html(dist);
        });
 
        directions.loadFromWaypoints(route);
      });
    }
  }
});

Maybe it is long but pretty straight forward. As you can read in my other examples, we first initialize jQuery, so it starts after our document is loaded. After that we define our map container and our markers. After we check if our browser is compatible and our map container exists, we initialize the map with couple options (large controls, zoom level = 14 and the center of the map).

We add two event listeners, which are triggered on onchange event of our drop downs (with id start and end respectively, the html code will follow). If you use the $option parameter in getDropDown function for displaying custom blank option, we check if the user chose this option and return false if he did. If he chose a valid option, we use an AJAX request and retrieve the geolocation from our helper file.

After our call returns some data, we check, if we have already any markers saved in our map and if we do, we first remove them and then place a new marker according to the option chosen in the drop down.

We repeat the same for the drop down with id 'end'. Actually we could have put this two events into a separate function, but to make this example clear I purposely didn't do that.

The last event listener is triggered, when a user clicks on a 'calculate route' button. First we check, if both points were placed by the user, and if not we display an alert, that he or she has to provide valid starting and ending point. This check might not work in IE, therefore you might need to do some changes, so it also works in IE.

We initialize GDirections Class and define our route with starting and ending point. I also use the getDistance method to display the amount of kilometers between this two points. As the last thing we need to do is to display the directions on the map and voila, we are done

What we still need it the rest of index.php file and our helper, and KML file.

1
2
3
4
5
6
7

<div id="navigation">
        Start <?php echo $geo->getDropDown('start', array('include_custom' => 'please choose...')); ?>
        Stop <?php echo $geo->getDropDown('end', array('include_custom' => 'please choose...')); ?>
        <input type="button" name="submit" id="submit" value="calculate route" />
</div>
<div id="distance"></div>
<div id="map" style="width: 1000px; height: 600px;"></div>

Pretty straight forward. We display our navigation with an empty option 'please choose...', the 'calculate route' button and containers for distance and map.

3. Our helper - helper.php

1
2
3

include('Geo.class.php');
$geo = new Geo();
echo json_encode($geo->getLocation($_GET['location']));

Pretty simple, isn't it Just initialize the class and call the method to retrieve location with the location argument used in the _GET request.

4. KML file - geo.xml

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

<?xml version="1.0" encoding="UTF-8"?>
<kml xmlns="http://earth.google.com/kml/2.2">
  <Placemark>
    <name>Alexanderplatz</name>
    <description>Center of Berlin</description>
    <Point>
      <coordinates>52.52238370531909,13.409671783447266</coordinates>
    </Point>
  </Placemark>
  <Placemark>
    <name>Frankfurter Tor</name>
    <description>A nice place to live</description>
    <Point>
      <coordinates>52.51595970749194,13.4527587890625</coordinates>
    </Point>
  </Placemark>
  <Placemark>
    <name>Warschauerstr.</name>
    <description>Place to go and spend some time with friends</description>
    <Point>
      <coordinates>52.508568336719854,13.451085090637207</coordinates>
    </Point>
  </Placemark>
  <Placemark>
    <name>Revelerstr.</name>
    <description>Cassiopeia Club</description>
    <Point>
      <coordinates>52.50721006978328,13.457050323486328</coordinates>
    </Point>
  </Placemark>
  <Placemark>
    <name>Frankfurter Allee</name>
    <description>Shopping Center</description>
    <Point>
      <coordinates>52.513818166144006,13.474087715148926</coordinates>
    </Point>
  </Placemark>
</kml>

It is a file I prepared by myself. As far as I know, you can create them using the Google Earth application. Probably they can be way more complex than this one. But I guess it will be a nice subject for next example Good luck with this one and as usually, in case of any question, you know how to find me. Cheers!

You have managers, executives and simple workers. To validate a manager we generated codes which we later distributed between them. Executives and simple workers didn't have to use a validation code. Therefore a simple input field of type text was provided only if a person registering on our site chose the position manager. Therefore I couldn't make this field as required because it was only required for a certain group of people registering on our site.

The validation rule was simple. I compared the code provided during registration with the one saved in the database and returned true or false according to the case. The problem I encountered was in the case that if a person chose manager and did not provide any input (an empty field), the error message was not displayed at all. I mean you could probably solve this problem using JavaScript but server side validation is always important. Researching the core code of symfony I found a place where this case is not considered an error. I could possibly change the core, but I didn't want to do that only for one case. I mean, if it would be a problem with many fields I would probably consider it necessary, but I've found a solution for that problem without changing the core code. Here is how I accomplished it.

I assume that you are familiar with symfony framework, therefore I wont explain the whole process from the beginning. In my /apps/myproject/lib folder I created a class extending sfValidation class, where I placed the database check. Unfortunately, defining additional string validation rules ($string == null etc.) in that class did not solve my problem that an error did not appear when the field was empty.

I did some more reading and I've found a really interesting solution. In your action.class.php file besides executeXXX() methods you can define additional validateXXX() methods, which are executed before executeXXX() methods. I placed a simple string validation rule in this method (with min value of 1) and it works like a charm right now. Below you can see my code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public function validateIndex() {
  //manager code validation
  if($this->getRequestParameter('position') == 'manager') {
    $managerCode = $this->getRequestParameter('manager_code');
 
    $val = new sfStringValidator();
    $val->initialize($this->getContext(), array(
      'min' => 1,
    ));
    if (!$val->execute($managerCode)) {
      $this->getRequest()->setError('managerCode', $this->getContext()->getI18N()->__('You have to fill out the code', null, 'user'));
      return false;
    }
    return true;
  }
}

As I said before this approach might get pretty annoying if you are dealing with multiple fields but for me it was just this one. I hope this solution will help you during your development. As usually I'm waiting for your feedback. Cheers!

The first thing you need to do is to go to getpos.de and register a new account. Unfortunately this service is only in German, but I don't think you should have any problem with registering a new account. Let's take a look at our class:
[source:php]
class Geolocation {

private $ip;
private $xml_data;
private $xml;

public $geo;
public $error;

function __construct($ip) {
$this->ip = $ip;
$this->xml_data = simplexml_load_file("http://services.getpos.de/ip2loc.asmx/GetIPPosition?UserName=YOUR_USERNAME&Password=YOUR_PASSWORD&IPAddress=".$this->ip);
}

public function findGeo() {
if(!$this->xml_data) {
$this->error = "service unavailable";
return false;
}
$this->xml = new SimpleXMLElement($this->xml_data);
$this->RecurseXML($this->xml,$this->geo);
}

private function RecurseXML($xml,$vals,$parent=""){
$child_count = 0;
foreach($xml as $key=>$value) {
$child_count++;
$k = ($parent == "") ? (string)$key : $parent.".".(string)$key;

if($this->RecurseXML($value,$this->geo,$k) == 0)
$this->geo[$k] = (string)$value;
}
return $child_count;
}
}
[/source]
We define IP address, XML data and an instance of SimpleXMLObject as private properties and our error handler and actual geo data as public properties. In our constructor we pass IP address and we use simplexml_load_file function to interpret the XML file into an object. Obviously you need to replace YOUR_USERNAME and YOUR_PASSWORD with the information you will use to register at getpos.de. In findGeo() method we first check, if the service is available, and if not we show error message. If our service is available though, we instantiate SimpleXMLObject with the XML data. We than use RecurseXML() method to translate our object into a suitable array. The credit for RecurseXML() goes to transglobe at gmx dot de. I found this function in the comments section of PHP manual and changed it a little bit to suit our needs.

Let's take a closer look, how to use our class:
[source:php]
include("geolocation.class.php");
$geo = new Geolocation($_SERVER['REMOTE_ADDR']);

$geo->findGeo();
echo (isset($geo->error)) ? $geo->error : '';

echo "geo['returncode']:".$geo->geo['returncode']."
";
echo "geo['country.code']:".$geo->geo['country.code']."
";
echo "geo['country.name']:".$geo->geo['country.name']."
";
echo "geo['region.code']:".$geo->geo['region.code']."
";
echo "geo['region.name']:".$geo->geo['region.name']."
";
echo "geo['city']:".$geo->geo['city']."
";
echo "geo['position.longitude']:".$geo->geo['position.longitude']."
";
echo "geo['position.latitude']:".$geo->geo['position.latitude']."
";
echo "geo['returncode']:".$geo->geo['returncode']."
";
[/source]
We include our class and instantiate it with the remote address of a visitor. We than call findGeo() method, which will translate the IP address for us. We can than echo our results or just use them to display relevant information for our users. Obviously, if a user is connected through a proxy or some AOL users in Europe, who are connected through American servers, this class wont retrieve correct information. You need to take into consideration though, that about 65% of your visitors will get correct content. I hope it is clear enough. If you encounter any problems with this class please let me know. As mentioned before, it would be also nice if you could give me any feedback about the accuracy of this service.

Let's start with defining our class, some variables and the constructor.
[source:php]
class Register {

//@string name of table, where the information will be stored
private $table_name;
//@array holds user input
private $input;
//@string subject of confirmation email
private $mail_subject;
//@string body of confirmation email
private $mail_body;
//@bool html mail true/false
private $mail_html;
//@array displays error messages
public $error;

function __construct() {
$con = mysql_connect('localhost','root','pass') or die(mysql_error());
if($con) {
mysql_select_db('test',$con);
}
$this->table_name = "test_user";
$this->mail_subject = "confirmation mail";
$this->mail_body = "Here comes the text of confirmation e-mail. Click on this link %s to confirm your email.";
$this->mail_html = true;
}
}
[/source]
$this->table_name is a string property, which holds information about MySQL table, in which we will save our new registered user. $this->input is an array, in which we will save the user input. As you will see later, we do that, to make the user input safe for MySQL INSERT function. $this->mail_subject and $this->mail_body are two properties, which will be responsible for holding the information we will later send to our new user after successful registration. $this->mail_html is a boolean property, which tells our script to either send HTML or plain text e-mail after successful registration. $this->error property is an array, which we will use to display all errors to the user, which our script will generate. In our constructor method we initialize data base connection and all the properties we will later use in our class. Let's move farther to our registration method.
[source:php]
public function registerUser() {
foreach($_POST as $k=>$v) {
$this->input[$k] = mysql_real_escape_string($v);
}
//Check users input
if($this->checkInput()) {
//Check, if username exists already
if($this->checkUser('username')) {
//Check if email exists already
if($this->checkUser('email')) {
//save user in database
if($this->insertUser()) {
//send mail with confirmation link
if($this->sendMail()) {
$this->success = "Thanks for registration. Check your e-mail for further details.";
return true;
} else {
//revert changes in database
$this->deleteUser();
$this->error[] = "something went wrong, please try again later send mail";
return false;
}
} else {
$this->error[] = "something went wrong, please try again later insert user";
return false;
}
} else {
$this->error[] = "email exists";
return false;
}
} else {
$this->error[] = "username exists";
return false;
}
} else {
return false;
}
}
[/source]
We define this method as public because we will call it after our user clicks the submit button. We than loop through the $_POST variable and make the input safe against MySQL injection. First we check, if all the input is valid and meets our expectations according to password length, valid email etc. After that we provide a user check against the information saved in our database to determine, if an user with provided username or e-mail exists in our database. If it does we display corresponding error message. If our script passes this check we save new user in our database and send an e-mail with activation link. If our script return true after sending an activation e-mail we display a success message for our user with prompt to check his/hers e-mail and activate account. Simple logic, you can probably find in each user authorization. Let's take a closer look at corresponding methods, which I just mentioned:
[source:php]
private function checkInput() {
if(strlen($this->input['username']) < 5 || $this->input['username'] == '') {
$this->error[] = "username too short";
}
if(strlen($this->input['username']) > 16) {
$this->error[] = "username too long";
}
if($this->input['password'] == '' || $this->input['password1'] == '') {
$this->error[] = "you need to provide a password";
}
if($this->input['password'] != $this->input['password1']) {
$this->error[] = "password mismatch";
} else {
$this->input['password'] = md5($this->input['password']);
}
return (is_array($this->error) && !empty($this->error)) ? false : true;
}
[/source]
This method validates user input. It is just a simple example and it doesn't validate the e-mail address. You should feel free to add any other validations you can imagine to this method. In the last step we check, if provided passwords match and if they do, we encode the password with md5() function. We do that to ensure the user, that his or hers data wont be abused later, when we use it for example to save it in session variables and check against database information to authenticate the user. If $this->error is an array and it's not empty, it means user input is not valid and we return false, otherwise true.
[source:php]
private function checkUser($case='') {
switch($case) {
case 'username':
$sql = mysql_query("SELECT COUNT(*) AS exist FROM ".$this->table_name." WHERE username='".$this->input['username']."';");
break;
case 'email':
$sql = mysql_query("SELECT COUNT(*) AS exist FROM ".$this->table_name." WHERE email='".$this->input['email']."';");
break;
default:
break;
}
return (mysql_result($sql,0,'exist') > 0) ? false : true;
}
[/source]
In this method we check, if username or password exists in database. If it does we return false, otherwise true. At this point I should probably mention that AJAX gives you possibility to perform this validation on client side. Server side validation is just another check to ensure that provided data is really that, what we expect to save in our database. If you want to use this class in your AJAX request to perform checks on user input, you would have to change most of the methods to public and probably write another method which will set user input you will later use to perform those checks.
[source:php]
private function insertUser() {
$sql = mysql_query("INSERT INTO ".$this->table_name." (id, username, password, email, confirmed) VALUES (NULL,'".$this->input['username']."','".$this->input['password']."','".$this->input['email']."','0');") or die(mysql_error());
return ($sql) ? true : false;
}

private function deleteUser() {
$sql = mysql_query("DELETE FROM ".$this->table_name." WHERE username='".$this->input['username']."' AND email='".$this->input['email']."';");
}
[/source]
InsertUser and deleteUser are just simple methods to either save of delete a user from the database.
[source:php]
private function sendMail() {
if($this->email_html) {
$header = 'MIME-Version: 1.0' . "\r\n";
$header.= 'Content-type: text/html; charset=iso-8859-1' . "\r\n";
$header.= 'From: "yourmail@domain.com"' . "\r\n";
} else {
$header = 'From:yourmail@domain.com';
}

$body = sprintf($this->mail_body,"www.yourdomain.com?activation=youractivationcode");

return (@mail($this->input['email'], $this->mail_subject, $body, $header)) ? true : false;
}
[/source]
The last method replaces %s with the confirmation link, sends a confirmation mail and returns true on success and false in case of any errors. That's all. As I already mentioned this class doesn't provide a ready solution for your internet site and it should be adjusted to your needs. It's just a schema you can always start with, when you writing applications, which provide user registration. At the end lets take a closer look, how you should use this class.
[source:php]
if(isset($_POST['submit']) && $_POST['submit'] == 'register') {
include('register.class.php');
$register = new Register;
if($register->registerUser()) {
echo (isset($register->success)) ? $register->success : '';
} else {
foreach($register->error as $error) {
echo $error."
";
}
include('form.php');
}
} else {
include('form.php');
}
[/source]
We include and instantiate our class only in case, when our clicks a submit button. We then call the registerUser method and display success or error message depending on the case. You might also provide a redirection after successful registration to prevent the users from reloading the page. However our class would retrieve an error message saying that username already exists, it is just a nice way to do the things. And here the code of form.php in case you need it:
[source:html]

[/source]
And the table structure:
[source:sql]
CREATE TABLE IF NOT EXISTS `test_user` (
`id` int(11) NOT NULL auto_increment,
`username` varchar(50) collate latin1_general_ci NOT NULL,
`password` varchar(32) collate latin1_general_ci NOT NULL,
`email` varchar(255) collate latin1_general_ci NOT NULL,
`confirmed` enum('0','1') collate latin1_general_ci NOT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `username` (`username`)
)
[/source]
I'm waiting for your comments about this one. Cheers.

(You can find a downloadable archive at the end of this example)

Let's start with defining the class and some configuration variables.
[source:php]
class Upload {
private $image = array();
private $image_location;
private $image_type;
private $image_height;
private $image_width;
private $image_maxheight;
private $image_maxwidth;
private $image_box;

public $error;
public $success;
}
[/source]
We set all of important variables as private, because we will use them only in the scope of our class. Two public variables will be responsible for displaying the error and success messages. Let's go to our constructor.
[source:php]
function __construct() {
$this->image_location = 'images/';
$this->image_height = 60;
$this->image_width = 60;
$this->image_maxheight = 1500;
$this->image_maxwidth = 1500;
$this->image_box = 60;
}
[/source]
In our constructor method, which will be executed, after we initialize our class, we will define some basic configuration. $this->image_location property will tell our script, where to save the images. Before you start using this class, don't forget to create this directory and give it necessary rights, because otherwise you will get an error message. $this->image_width and $this->image_height tell our script, to which width or height should the image be resized. Both properties should have the same value, which shouldn't be bigger than the value of $this->image_box. Our script will automatically detect, if the picture is horizontal or vertical and will use the right value according to the case. $this->image_box tells our script, which resolution has the div box displayed on the start page. $this->image_maxheight and $this->image_maxwidth is the maximum resolution of the picture, which cannot be exceeded. Let's move to the picture upload.
[source:php]
public function uploadPicture() {
foreach($_FILES as $file) {
$this->image['tmp_name'] = $file['tmp_name'];
$this->image['name'] = $this->image_location.$file['name'];
$this->image['type'] = $file['type'];
}
return ($this->createPicture()) ? true : false;
}
[/source]
In our first public method, which will be called, after a user clicks an upload button, we set some important properties, which we will use later to handle our image upload. $this->image['tmp_name'] will hold for us the temporary location of the file. $this->image['name'] will hold the location, where the uploaded image should be copied, and $this->image['type'] will hold MIME type of the uploaded picture. After we set those properties, we call createPicture method to actually create the pictures for us. Let's take a closer look at two last methods.
[source:php]
private function createPicture() {
if($this->checkType()) {

move_uploaded_file($this->image['tmp_name'],$this->image['name']);
list($width, $height, $type, $attr) = getimagesize($this->image['name']);

if ($width > $this->image_maxwidth || $height > $this->image_maxheight) {

$this->error = 'Your picture is too big';
unlink($this->image['name']);
return false;

} else {

if($height > $width) {
$this->image_width = round((($this->image_height * $width) / $height));
$x = round(($this->image_height - $this->image_width) / 2);
$y = 0;
} else {
$this->image_height = round((($this->image_width * $height) / $width));
$x = 0;
$y = round(($this->image_width - $this->image_height) / 2);
}

if($this->image_type == 'jpg') {
$galery_image = imagecreatefromjpeg($this->image['name']);
} elseif($this->image_type == 'gif') {
$galery_image = imagecreatefromgif($this->image['name']);
} else {
$galery_image = imagecreatefrompng($this->image['name']);
}

$image = imagecreatetruecolor($this->image_box, $this->image_box);
$background = imagecolorallocate($image, 255, 0, 0);
imagefill($image, 0, 0, $background);

imagecopyresampled($image, $galery_image, $x, $y, 0, 0, $this->image_width, $this->image_height, $width, $height);

if($this->image_type == 'jpg') {
imagejpeg($image, $this->image['name']);
} elseif($this->image_type == 'gif') {
imagegif($image, $this->image['name']);
} else {
imagepng($image, $this->image['name']);
}

chmod($this->image['name'], 0644);
imagedestroy($image);

$this->success = 'Image uploaded successfully';
return true;
}
} else {
return false;
}
}

private function checkType() {
switch ($this->image['type']) {
case 'image/jpeg':
case 'image/jpg':
case 'image/pjpeg':
$this->image_type = "jpg";
return true;
break;
case 'image/gif':
$this->image_type = "gif";
return true;
break;
case 'image/png':
case 'image/x-png':
$this->image_type = "png";
return true;
break;
default:
$this->error = "Wrong file type";
return false;
break;
}
}
[/source]
Because this two method are pretty long I will split them into smaller pieces and explain step by step. We set both of the methods as private, because we will use them only in the scope of our class. It the first method, createPicture, we first check, if the MIME type of the file uploaded by a user is supported by our script. If it is we set $this->image_type and return true, if not we display error message and return false.
[source:php]
move_uploaded_file($this->image['tmp_name'],$this->image['name']);
list($width, $height, $type, $attr) = getimagesize($this->image['name']);

if ($width > $this->image_maxwidth || $height > $this->image_maxheight) {

$this->error = 'Your picture is too big';
unlink($this->image['name']);
return false;

}
[/source]
In this part we actually move the uploaded file from the temporary location to the location we defined earlier in our script. After that we list the width and height from our new uploaded image and check, if they are not bigger, then the values we defined in our constructor. If they are, we display an error message, if not we proceed.
[source:php]
if($height > $width) {
$this->image_width = round((($this->image_height * $width) / $height));
$x = round(($this->image_height - $this->image_width) / 2);
$y = 0;
} else {
$this->image_height = round((($this->image_width * $height) / $width));
$x = 0;
$y = round(($this->image_width - $this->image_height) / 2);
}
[/source]
If the resolution of the image is correct, we check, if the image is vertical or horizontal. According to the case, we calculate new width or new height and the offset, which we will later use to place the image in the middle of our box.
[source:php]
if($this->image_type == 'jpg') {
$galery_image = imagecreatefromjpeg($this->image['name']);
} elseif($this->image_type == 'gif') {
$galery_image = imagecreatefromgif($this->image['name']);
} else {
$galery_image = imagecreatefrompng($this->image['name']);
}

$image = imagecreatetruecolor($this->image_box, $this->image_box);
$background = imagecolorallocate($image, 255, 0, 0);
imagefill($image, 0, 0, $background);

imagecopyresampled($image, $galery_image, $x, $y, 0, 0, $this->image_width, $this->image_height, $width, $height);
[/source]
In this step we return an image identifier according to the MIME type of the picture, which has been uploaded and create an empty image, in which we will place the uploaded picture. You can change the $background and use your own color for the background using the RGB values. Imagecopyresampled uses our identifier and the "picture box" we creted with predefined values and creates a ready image.
[source:php]
if($this->image_type == 'jpg') {
imagejpeg($image, $this->image['name']);
} elseif($this->image_type == 'gif') {
imagegif($image, $this->image['name']);
} else {
imagepng($image, $this->image['name']);
}

chmod($this->image['name'], 0644);
imagedestroy($image);

$this->success = 'Image uploaded successfully';
return true;
[/source]
In the last part, according to MIME type, we output our new created picture to the file, change the permissions and destroy the original image.

Let's take a closer look, how you should use this class.
[source:php]
if(isset($_POST['submit']) && $_POST['submit'] == 'upload') {
include('upload.class.php');
$upload = new Upload;
if($upload->uploadPicture()) {
echo (isset($upload->success)) ? $upload->success : '';
echo '
go back';
} else {
echo (isset($upload->error)) ? $upload->error : '';
echo '
go back';
}
} else {
?>

}
?>
[/source]
I think, this code doesn't need a detailed explanation. One hint only: don't forget to set the enctype of the form to multipart/form-data, because otherwise the $_FILES variable wont be initialized. If user clicks on upload button, we initialize our class and use the uploadPicture method to create our new picture. If this method returns true we display success message, if not the error message.

That's all. I hope it was clear enough for you, what I was trying to accomplish in this example. You can change it in probably hundreds different ways and adjust it to your own needs. Feel free to do that.

You can download all of the files here.

private $url = array();

}
[/source]
We define private array url, in which we will store URLs prepared for cURL request. Let's build a contructor.
[source:php]
class Geolocation {

private $url = array();

function __construct($file) {
$gmapkey = "YOURKEY";
$address = file($file);
foreach($address as $addres) {
$this->url[] = "http://maps.google.com/maps/geo?q=".urlencode($addres)."&output=csv&key=".$gmapkey;
}
}
}
[/source]
You need to replace $gmapkey with the key you can sign for at google. Our __constructor reads the text file and saves each line in an array. We then loop through this array and initialize URLs.

In the next method we will loop through the addresses to retrieve the geolocation.

[source:php]
class Geolocation {

private $url = array();

function __construct($file) {
$gmapkey = "YOURKEY";
$address = file($file);
foreach($address as $addres) {
$this->url[] = "http://maps.google.com/maps/geo?q=".urlencode($addres)."&output=csv&key=".$gmapkey;
}
}
public function getLatLng() {
$i=1;
foreach($this->url as $urls) {
$cinit = curl_init();
curl_setopt($cinit, CURLOPT_URL, $urls);
curl_setopt($cinit, CURLOPT_HEADER,0);
curl_setopt($cinit, CURLOPT_USERAGENT, $_SERVER["HTTP_USER_AGENT"]);
curl_setopt($cinit, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($cinit, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($cinit);
curl_close($cinit);

if(strstr($data,"200")) {
$data = explode(",",$data);
echo $i.": ";
$zoom = $data[1];
echo $lat = $data[2];
echo $lon = $data[3]."
";
}

/*
$sql = "INSERT INTO..."
$res = mysql_query($sql);
echo ($res) ? $i.": lat:".$latitude." lon: ".$longitdue." -- OK
" : $i.": ERROR
";
*/
$i++;
}
}
}
[/source]
You can either echo the results or just save them in your MySQL database. You can also make multidimensional array and save some extra information about the certain place.

Let's take a look at how you should use this class.
[source:php]
include('geolocation.class.php');
$geo = new Geolocation('address.txt');
$geo->getLatLng();
[/source]
Basically you need to include the class, initialize it with the name of the file you want to use and getLatLng will do the magic for you. This class is pretty old and you may encounter one problem using it. After 10th request I started to receive the same geolocation for different places. What you can do is to put the foreach loop to sleep for 2 seconds and it should be fine. That's why I actually use iterator in this function. You basically need to add this line right after the loop starts.
[source:php]
if($i%10 == 0) sleep(2);
[/source]

Here is the content of the text file:
[source:html]
Berlin, Dieffenbachstr. 38
Berlin, Cuvrystr. 32
Berlin, Lasdehner Str. 30
[/source]
Basically one address per line. That would be all, have fun with playing and extending this class.

Here you can find a working demo of the class I will introduce in this example

Let's start with defining the class and the variables we will use in the scope of this class. We will give it a Login name because it has to handle a user, who wants to login to view certain content, which is available only for registered users.

class Login {
 
    private $user_name;
    private $user_pass;
    private $user_id;
    private $user_access;
    public $login_error;
 
    function __construct($username,$userpass)  {
        $this->user_name = $username;
        $this->user_pass = (isset($_SESSION['user']])) ? $userpass : md5($userpass);
    }
 
}

We declared the properties of this class as private, because we will use them only in scope of it and we will access them only internally from this class. The only public property will be responsible for error handling. We use __construct function to assign values to the properties we just declared, when the class will be initialized. We assume that password stored in database was encrypted using md5() function. As the first step we will declare a method, which will handle user login.

public function loginUser() {
    if($this->checkUser()) {
        $this->setUser();
        header("Location:index.php?page=overview");
    } else {
        $this->error_login = 'wrong username or password';
    }
}

We set the loginUser function to public so we can access it after we initialize our class. We check, if the user exists in our database. If the information in database matches the user input, we use setUser function to store the information about the user, which we can use later to authenticate or to get user content availably only for that certain user.

As second step we will declare a private method checkUser, which will check, if a the information provided by user exists in database. This will be a simple MySQL query and the method will return true in case user exists and false in case of any mismatch.

(In this place you might comment out MySQL check and just add hard coded check for certain string. I add this part as a commentary.)

private function checkUser() {
    /*
    return ($this->user_name == 'demo' && $this->user_pass == 'demo') ? true : false;
    */
    $sql = sprintf("SELECT COUNT(*) AS exist FROM usertable WHERE username='%s' AND pass='%s' AND confirmed='1';",$this->user_name,$this->user_pass);
    $res = mysql_query($sql) or die(mysql_error());
    return (mysql_result($res,0,'exist') == 1) ? true : false;
}

In the next step we will define a method, which will set our user as a session array, where we will store all the important information about our user.

(Again, if you don't want to use database, you can define default user id.)

private function setUser() {
    /*
    $this->user_ip = 1;
    */
    $sql = sprintf("SELECT id FROM miss_user WHERE username='%s' AND pass='%s';",$this->user_name,$this->user_pass);
    $res = mysql_query($sql) or die(mysql_error());
    $this->user_id = mysql_result($res,0,'id');
    $_SESSION['user'] = array('user_id'=>$this->user_id, 'user_name'=>$this->user_name, 'user_pass'=>$this->user_pass, 'user_ip'=>$_SERVER['REMOTE_ADDR']);
    setcookie('userip',$_SERVER['REMOTE_ADDR'],0);
}

As you can notice we saved user id, user name, user password and user remote address in an array, which we will later use to authenticate user. We declared this method as private again, because we will access it only in the scope of our class. Additionally we save a cookie with the IP address of the user to perform a check against session stealing. Even if someone would try to steal the session by just randomly typing it into the URL address, the authentication will be failed because it wont match the IP in the cookie.

In this step we will actually perform the authentication of a user.

public function authenticateUser($user) {
    if(is_array($user) && !empty($user)) {
        if($this->checkUser()) {
            return ($_COOKIE['userip'] == $_SESSION['user']['user_ip']) ? true : false;
        } else {
            return false;
        }
    } else {
        return false;
    }
}

First we check, if the session array is an array at all and if it's not empty. After that we perform checkUser again to compare the session array with the database information. At the end we do the last check, if the IP address saved in the cookie matches the address saved in session array. In my case the method authenticateUser returns true on success and false in case of failure but you can do whatever you want after a user passes authentication. We save id of a user because it might be useful later in getting the information relevant only for this certain user or from two MySQL tables, which are related to each other by an user ip.

The only thing, which we are missing right now is the log out method.

public function logOut() {
    unset($_SESSION['user']);
    setcookie('userip','',time()-3600);
    header("Location:login.php");
}

I think this is self explanatory. We unset the sessionn, destroy the cookie and redirect the user to the login page. That would be all. Now i will present a simple usage of this class.

session_start();
error_reporting(E_ALL);
include('class.login.php');
if(isset($_POST['submit']) && $_POST['submit'] == 'login') {
    $login = new Login($_POST['username'],$_POST['pass']);
    $login->loginUser();
} elseif(isset($_SESSION['user']) && is_array($_SESSION['user']) && !empty($_SESSION['user'])) {
    $login = new Login($_SESSION['user']['user_name'],$_SESSION['user']['user_pass']);
}
 
if(isset($_GET['page']) && $_GET['page'] == 'logout') {
    $login->logOut();
}

We start a session and include our class before we send any headers. We use error_reporting only for develpment reasons and you can erase this line or decrees the level of error reporting if you want. We perform a check, if user submit the login form. If yes we initialize the Login class with the information provided by user. If the input validates we log in user and redirect him to welcome page (as stated in the class). If the user didn't submit the login information we perform another check, if the session array is set and if it's not empty we initialize our class with the information saved in our session array. If the user clicks on the log out button, we use logOut method to destroy all the information about the user. After that we can send some headers.

<?php
if(isset($_SESSION['user']) && $login->authenticateUser($_SESSION['user'])) {
    if(isset($_GET['page']) && $_GET['page'] == 'logged') {
?>
        <a href="login.php?page=logout">Logout</a>
<?php
    }
} else {
    echo (isset($_POST['submit'])) ? $login->error_login : '';
?>
<form action="<?=$_SERVER['PHP_SELF']?>" method="post">
username:<input name="username" type="text" />
password:<input name="pass" type="text" /> <input name="submit" type="submit" value="login" />
</form>
<?php
}
?>

In this part we perform actual authentication of the user and display information for authenticated users and if there is any error we display the error message

Wow I did it. It's my first tutorial kind of example thing:) If you want to download the files with source code for this example you can do it here. I'm waiting for your feedback right now. If you went that far you can write at least couple words:) Going back to work now...