I am an experienced developer with my own transport and will come to you for an initial no obligation face to face meeting.

I am also considering fulltime employment with salary offers exceeding R35K.

Call  / SMS me on 079 9111 855

Email info@mydeveloper.co.za.

I will get to you as soon as possible.

Brief Profile

I am an innovative, dynamic and self-motivated web/php  developer with proven solid technical skills in programming, advanced website and web based systems development, deployment and maintenance. I am a resourceful and analytical problem solver, strategic thinker, effective communicator at all levels, both verbally and in writing. I am a natural leader with a yearning passion for quality and success and I quickly acclimatize to new environments

Key Skills

Programming Skills: PHP,ASP, MVC Frameworks – Code Igniter , CakePHP ,SOAP , REST , HTML ,Advanced XHTML and CSS , W3C Web Standards, Jquery , Mootools ,  Javascript , JSON , Graphic design ,and Photo editing. Proficient user of Dreamweaver CS23/CS4, Photoshop CS3 , Illustrator , Fireworks ,  Dreamweaver , Contribute.

Open Source Platforms: Joomla , Drupal , Wordpress , OsCommerce , ZenCart , CubeCart , OpenCart

Web Servers: Apache Http Server, Apache Tomcat 4.0. , IIS

DBMS: MySql, MS SQL,

Analysis/Design Methodologies: UML, OOAD, Unified Modeling Process.

If you require a PHP developer for your project

please call Mark on 079 9111 855 or email info@mydeveloper.co.za.

No related posts.

Related posts brought to you by Amazon plugin.

If you are considering freelance work, make sure that you think through the many advantages and disadvantages of freelancing before making any decisions.

Advantages Of Freelance Work
There are many advantages of freelance work. One of the greatest advantages of freelance work is the ability to work from home. No more need for work clothing, commuting time, commuting expenses, sharing an office, working in a cubicle or inane chats during tea breaks.

Another great advantage is the ability to be your own boss. No more being assigned projects you don’t want, having to work with team-mates you don’t respect or worrying about who is looking over your shoulder. Also, freelancing allows you to use a variety of skills on a variety of projects all at the same time. This can be fantastic for individuals who enjoy diverse tasks and topics and work best when they have multiple balls to keep in the air.

Individuals who work well under pressure and are well organised may find freelancing a great idea as they take on all responsibilities for every project, something that is not for the faint of heart!

Disadvantages Of Freelance Work
Freelancing does have its disadvantages as well. One great disadvantage it is that it is a very isolated way to work. When you work from home it is easy to be alone for hours and even days on end. Contact with others often comes in the form of phone calls, faxes or emails so a freelance must often make a point to leave the house and see other people.

Another disadvantage is having to be your own boss. Freelancing can be a nightmare for people who are not good with deadlines, following up on projects, collecting payments or enforcing contract clauses. Also, freelance work necessarily requires a lot of paperwork. Contracts, invoices, client communication, marketing supplies – all of this must be organised and used effectively by a freelance worker. People who are inherently uncomfortable with such organisation often find freelance work a challenge, particularly when it comes to organising a client folder or getting paperwork ready for taxes.

Finally, freelance work is often described as a feast or famine profession. This can make it hard to anticipate weekly, monthly and especially yearly profits, and it can be hard to anticipate when the payments will actually come in. This can be nerve-wracking for many people, so it must be remembered that those who do not enjoy risks may not enjoy freelance work.

There are many advantages and disadvantages to freelance work, just as there are to any other type of job. If you want to learn more about what it is really like to be a freelance worker, contact an individual in your area and see if you can pick their brains or even shadow them for a day. Learning from someone in the trenches is often the best way to decide if freelancing is for you.

No related posts.

Related posts brought to you by Amazon plugin.

I’m pitting these two frameworks against each other but there really isn’t a clear winner. Each has its strengths and weaknesses and ultimately falls to what your preference for certain features might be.
Why compare these two?

CakePHP and CodeIgniter are quite similar in their approach on a number of things, including their support for PHP4. Any mention of one inevitably leads to someone mentioning the other.

They both attempt to create an MVC architecture which simply means they separate the (data) Model from the Controller (which pulls data from the model to give to the view) from the View (what the user sees).

They both use Routing which takes a URL and maps it to a particular function within a controller (CakePHP calls these actions). CodeIgniter supports regular expressions for routing, whereas you’ll have to wait until CakePHP 1.2 for that feature. Correction: CakePHP 1.1 supports regular expression for routing but it’s not detailed in the manual and is getting updated in 1.2.

They both support Scaffolding which is an automated way of generating a view based on the model. Scaffolding is meant for simple prototyping and CodeIgniter takes it a step further by requiring a keyword in the URL to even access the scaffolding. I’m guessing one could omit the keyword, leaving this feature essentially optional. I prefer not to have to use the keyword as I sometimes build personal projects not intended for public eyes and using a keyword would be a nuisance.

And the list goes on…
Approach to Simplicity

I believe much of CodeIgniter’s appeal is its simplicity in its approach. Most of the work is done in the controller, loading in libraries, getting data from the model, and pulling in the view. Everything is in plain sight and you can really see how things work.

CakePHP’s simplicity comes via automation (euphemistically referred to as “automagic”). It makes the coding process quicker but harder to figure out “what is going on” without popping your head into the core. For me, I like to understand how everything works and I’ve had to poke around under the hood more than once. For people just getting started, things probably look a little daunting.
Working with Models

CodeIgniter’s model handling is fairly straightfoward and basically allows you to mimic a standard SQL query with a few straightforward commands like these examples:

$query = $this->db->getwhere(‘mytable’, array(id => $id), $limit, $offset);

$this->db->select(‘title’)->from(‘mytable’)->where(‘id’, $id)->limit(10, 20);
$query = $this->db->get();

Note: the method chaining in the second part of this example is only available in PHP5.

You can also create a model object, load it in and build custom methods to handle a custom task. You’d want to do this in the model and not the controller to help isolate code into the MVC silos.

CakePHP takes a slightly different route by automatically loading in the model that matches the current controller (controllers tend to be named similarly to the models they are associated with). You can turn off this automated loading and even assign different models that should be loaded by the controller instead.

CakePHP also takes things further by establishing all the model associations for you, allowing for some really easy querying. For example, assuming I’m in a controller named post_controller, I could do the following:

$this->Post->Comment->findAllByPostId($id)

I chose this particular query because it shows two different concepts. The first is the fact that I can access the Comment model via the Post model (assuming I’ve defined that association in the Post model). The second is the fact that I have a method called findAllByPostId. CakePHP allows records to be grabbed via findByX and findAllByX queries where X is equal to the field name you’re trying to find.

Where I think Cake shines is in its ability to pull in all associated data automatically. Take the following query as an example:

$this->Post->findById($id)

This query would automatically pull in all the comments associated with this Post. Really handy stuff.
Validation

When working with models, you’ll inevitably have to handle data validation. Data validation in CodeIgniter is handled via a validation class. A set of rules get defined and assigned to the validation object. The validation object automatically (I assume) validates the data passed via the URL or form. From there, you can decide how that gets handled. The validation class can also help automate some of the process of setting error messages for specific fields.

CakePHP handles its validation through the model itself in one of two ways. The first uses a single test against each field defined in a validate variable declared in the model. This works okay for simple stuff but it quickly becomes a cumbrance. Beyond simple validation, I take advantage of the beforeSave callback to perform any custom validation, invalidating any fields that fail.

It’s a toss up for me as to which one “wins”. CakePHP 1.2 will have its validation system reworked a bit to allow for more flexibility.
Views

CakePHP handles this fairly well by using a default layout (which you can easily switch at runtime). The layout has two variables be default: title_for_layout and content_for_layout. Each action automatically links to a particular view which gets spat into place. Again, it’s the “automagic” approach. As long as you name your files a specific way, controllers automatically get linked to models and views. It’s easy enough to override all of this, too, and define your own layouts or view files. There’s no convenient way to get the generated view data, however, making custom built caching mechanisms difficult to implement.

CodeIgniter takes a very straightforward approach: like include files, almost. Each file gets loaded in and processed. There’s a templating class but it doesn’t simplify things much beyond the built-in view handling. You can mimic the CakePHP approach by always including the header and footer calls but it’s not as seamless. CodeIgniter offers hooks allowing view and caching mechanisms to be overridden and replaced with a custom system.
Out of the Box Features

CodeIgniter in my mind wins this hands down with classes for FTP, Email, File Uploading, XMLRPC, Zip encoding and more.

CakePHP on the flip side comes pretty light but tries to make up for it using the Bakery. You can, like CodeIgniter, easily drop in 3rd party classes for any features you might need. Interestingly, although I haven’t tried it, you could probably drop in many of the CI classes into CakePHP without issue.
Auto-loading

CakePHP allows for application-wide changes to be done via the base application controller that all other controllers inherit from. Likewise, you can create global model methods using the application model file. However, you can fine tune things at the controller level using any of the controller-level callbacks (beforeFilter, afterFilter and beforeRender). Things like auto-loading helpers and components can also be specified easily at the individual controller level.

CodeIgniter allows for the auto-loading of helpers, libraries and plugins but does this application-wide.
Documentation

Documentation is key to understanding any framework well enough to develop within it.

CodeIgniter has a complete list of all components with each method and property documented within. CI also has forums and a wiki which feature a lot of user-submitted code.

CakePHP, on the other hand, isn’t as well organized. The manual is starting to show its age with some sections not really going much beyond what the API offers. Because of the format of the original documentation, you can also get it in other formats such as CHM and PDF. CakePHP has the Bakery which contains user-submitted articles, components, etc. The dev team also hangs out heavily on the IRC channel (#cakephp at irc.freenode.net). Finally, there’s the CakePHP Google Group which is pretty active.
Final Verdict

I’m a pretty pragmatic individual and I honestly feel that these two frameworks have a lot going for them. They take a much simpler approach to application development than the complexity that is something like Symfony.

I’m still personally a fan of CakePHP over CodeIgniter for much of the “automagic” that I mentioned. And it’s shortcomings have been getting addressed with each new iteration (1.2 will be a considerable leap over 1.1 but it will still be awhile before it’s released).

No related posts.

Related posts brought to you by Amazon plugin.

MySQL Table

Let’s begin by creating a database table.

CREATE TABLE `users` (
    `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
    `oauth_provider` varchar(10),
    `oauth_uid` text,
    `username` text,
    PRIMARY KEY (`id`)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1;

Quite simple: we will be setting up a table for user information with id, username, first and last name, the URL to the user’s picture, and registered date. Also, we’re adding both an oauth_provider and oauth_uid fields, to distinguish between different third party open authentication protocols and their identifiers. For example, let’s say that, next week, you decide that it’s a good idea to also let Twitter users in. Easy; you just set another value to the oauthprovider, and avoid duplicating oauthuid values.

The Facebook App

Let’s begin by creating a new application. Give it a name and agree to the terms and conditions. Next, grab both the API Key and Secret in the basic tab as shown below.

On the canvas tab, set both the Canvas URL and Post-Authorize Redirect URL to your localhost and path that the script will process — something like http://localhost.com/login_facebook.php?. Note the question mark at the end and the domain; both are required by Facebook. Simply set your hosts file to a valid domain name.

On the connect tab, set the Connect URL to the same value and set localhost.com (or the one you are using) as the Base Domain.

Now save, download the client library, and unzip facebook.php in the srcdir to a new directory created in the root.

Step 2. The Callback

The authentication flow has three steps:

1. The local script generates a URL asking the user for permission
2. Facebook returns to the Canvas URL specified with a GET parameter
3. The GET parameter authenticates the session

Let’s make a quick test before registering and login.

# We require the library
require("facebook.php");

# Creating the facebook object
$facebook = new Facebook(array(
    'appId'  => 'YOUR_APP_ID',
    'secret' => 'YOUR_APP_SECRET',
    'cookie' => true
));

# Let's see if we have an active session
$session = $facebook->getSession();

if(!empty($session)) {
    # Active session, let's try getting the user id (getUser()) and user info (api->('/me'))
    try{
        $uid = $facebook->getUser();
        $user = $facebook->api('/me');
    } catch (Exception $e){}

    if(!empty($user)){
        # User info ok? Let's print it (Here we will be adding the login and registering routines)
        print_r($user);
    } else {
        # For testing purposes, if there was an error, let's kill the script
        die("There was an error.");
    }
} else {
    # There's no active session, let's generate one
    $login_url = $facebook->getLoginUrl();
    header("Location: ".$login_url);
}

Now, go to http://localhost.com/login_facebook.php, and let’s see what happens. If you are redirected to Facebook and requested for permission, we are on the right track.

However, there might be two issues. The first one: if you’re redirected to Facebook, but it shows an error, there might be a missing value in the configuration. Go back to your application settings and check both the Connect and Canvas tabs and make sure the fields are ok as described above.

There might be another issue, where you see an error, like “Uncaught CurlException: 60: SSL certificate problem, verify that the CA cert is OK.” This happens because of the CURL settings. You’ll have to open facebook.php, find the makeRequest() method, and, inside the function, find this line:

$opts = self::$CURL_OPTS;

Immediately following it, add:

$opts[CURLOPT_SSL_VERIFYPEER] = false;

I hate hacking libraries, but I haven’t found another way. Well, let’s continue with user registration. I’ve also added a try/catch statement, because, if there’s an old session keys in the GET params in the URL, the script will die with a horrible error.

Step 3. Registration and Authentication

We’ll next be working with MySQL. Please note that I will not implement a data sanitizer, since I want to keep the code as short and on task as possible. Please keep this in mind: always sanitize your data.

First, let’s connect to the database.

mysql_connect('localhost', 'YOUR_USERNAME', 'YOUR_PASSWORD');
mysql_select_db('YOUR_DATABASE');

Now, let’s work on the $session conditional, in case we have a session.

# We have an active session; let's check if we've already registered the user
$query = mysql_query("SELECT * FROM users WHERE oauth_provider = 'facebook' AND oauth_uid = ". $user['id']);
$result = mysql_fetch_array($query);

# If not, let's add it to the database
if(empty($result)){
    $query = mysql_query("INSERT INTO users (oauth_provider, oauth_uid, username) VALUES ('facebook', {$user['id']}, '{$user['name']}')");
    $query = msyql_query("SELECT * FROM users WHERE id = " . mysql_insert_id());
    $result = mysql_fetch_array($query);
}

Note that I’m querying the database, looking for facebook as a oauth_provider; it’s generally a good idea, if you want to accept other OAuth providers (as twitter, Google Accounts, Open ID, etc.) and a oauth_uid, since it’s the identifier the provider gives to its user accounts.

The oauth_provider field could potentially lead to bad performance if we leave it as a text field type. As such, the best option is setting it to an ENUM type.

We have now a $result var with the values queried from the database. Let’s next add some sessions. Add this line at the beginning of your script.

session_start();

After the empty($result) conditional, append the following:

if(!empty($user)){
    # ...

    if(empty($result)){
        # ...
    }

    # let's set session values
    $_SESSION['id'] = $result['id'];
    $_SESSION['oauth_uid'] = $result['oauth_uid'];
    $_SESSION['oauth_provider'] = $result['oauth_provider'];
    $_SESSION['username'] = $result['username'];
}

As it makes little sense to authenticate a user who is already logged in, just below the session_start() line, add:

if(!empty($_SESSION)){
    header("Location: home.php");
}

And in the scripts which require authentication, just add:

session_start();
if(!empty($_SESSION)){
    header("Location: login_facebook.php");
}

And if you want to display the username, access it as an array.

echo 'Welcome ' . $_SESSION['username'];
# or..
echo 'Welcome ' . !empty($_SESSION) ? $_SESSION['username'] : 'guest';

Step 4. Additional Methods

Facebook has a ton of connect features, but here are four that I’ve found to be the most useful.

Legacy Methods

I might be missing something, but the FQL seems more flexible and easy than the Graph API. Fortunately, Facebook still lets developers use it, altough with the new library, it has changed a bit.

If you want the user id, first name, last name, squared thumbnail for the user picture, the biggest user picture available, and his or her gender, you can use the users.getInfo method.

    $uid = $facebook->getUser();
    $api_call = array(
        'method' => 'users.getinfo',
        'uids' => $uid,
        'fields' => 'uid, first_name, last_name, pic_square, pic_big, sex'
    );
    $users_getinfo = $facebook->api($api_call);

You can check the full list of fields available for Users.getInfo.

It is possible to achieve the same result, using FQL.

    $uid = $facebook->getUser();
    $fql_query  =   array(
        'method' => 'fql.query',
        'query' => 'SELECT uid, first_name, last_name, pic_square, pic_big, sex FROM user WHERE uid = ' . $uid
    );
    $fql_info = $facebook->api($fql_query);

Here’s the list of tables which can be accessed with FQL, as well as the fields available for the table users.

Extended Permissions

Facebook provides applications with some interaction with the user’s data – just as long as it’s authorized. With the old API, the authorization for additional permissions was exclusively available for the Javascript SDK (altough I’m not quite sure). With the new API, we can easily redirect the user to an authorization dialog in Facebook, and return to our site after the access is either granted or denied.

In the following example, we will be redirecting a user to authorize posts status updates, photos, videos and notes, the user’s real email address, birthday and access to photos and videos.

$uid = $facebook->getUser();

# req_perms is a comma separated list of the permissions needed
$url = $facebook->getLoginUrl(array(
    'req_perms' => 'email,user_birthday,status_update,publish_stream,user_photos,user_videos'
));
header("Location: {$url} ");

Here’s a full list of permissions. Note that you can specify both the url to direct to if the user accepts and the url to be redirected to if the user denies. The key for these array elements are next and cancel_url, respectively. Here’s a quick example:

$url = $facebook->getLoginUrl(array(
    'req_perms' => 'email',
    'next' => 'http://localhost.com/thanks.php',
    'cancel_url' => 'http://localhost.com/sorry.php'
));

If not specified, the default is the requesting script’s location.

Checking for Extended Permissions

Since the user can easily revoke permissions, the application should always check if a given permission is granted before using it, specially if it’s about publishing something. We will have to use the legacy API, as it seems it’s not fully implemented with the new one yet.

    $uid = $facebook->getUser();

    # users.hasAppPermission
    $api_call = array(
        'method' => 'users.hasAppPermission',
        'uid' => $uid,
        'ext_perm' => 'publish_stream'
    );
    $users_hasapppermission = $facebook->api($api_call);
    print_r($users_hasapppermission);

The ext_perm will only support the old list of available permissions.

Publishing to the Wall

Let’s post something to the wall after verifying the user has the publish_stream permission.

    # let's check if the user has granted access to posting in the wall
    $api_call = array(
        'method' => 'users.hasAppPermission',
        'uid' => $uid,
        'ext_perm' => 'publish_stream'
    );
    $can_post = $facebook->api($api_call);
    if($can_post){
        # post it!
        $facebook->api('/'.$uid.'/feed', 'post', array('message' => 'Saying hello from my Facebook app!'));
        echo 'Posted!';
    } else {
        die('Permissions required!');
    }

Essentially, we are making an API call to /<user_id>/feed, using the POST method (second argument) and an array as a third argument for the data to be sent. In this case, this third argument supports message, link, picture, caption, name and description. Here’s the code:

$facebook->api('/'.$uid.'/feed', 'post', array(
    'message' => 'The message',
    'name' => 'The name',
    'description' => 'The description',
    'caption' => 'The caption',
    'picture' => 'http://i.imgur.com/yx3q2.png',
    'link' => 'http://net.tutsplus.com/'
));

Here’s how it is posted.

Some Additional Information you Should Know:

The user can easily revoke permissions with two clicks in his or her wall. You should heavily test what might happen if a user revoked one or more permissions that are vital for the proper functioning of your website, or even if the application is fully removed. This is important.

• In Application Settings you can remove the application entirely by clicking the x at the right side.
• You can remove permissions individually in the Granted Additional Permissions section.

5. Conclusion

While Facebook’s authentication capabilities are indeed useful, since so many people are on Facebook these days, using it as the only method of authentication in a site is not recommended. What about those who don’t have Facebook accounts? Are they not allowed to access your application? Thanks for reading!

No related posts.

Related posts brought to you by Amazon plugin.