Photo: Wikipedia

The approach outlined here makes a few assumptions.

• Tank Auth 1.0.9 installed in CodeIgniter 2.1.0
• MySQL (5)
• The default group ID will be ’300′
• The admin group ID will be ’100′

Here is an overview of the steps…

1.  Add a group/roles column to the users table in the database
2.  Create a library in CodeIgniter that extends Tank Auth with groups/roles support
3.  Create a model in CodeIgniter that extends the Tank Auth ‘users.php’ model
4.  Change everywhere the Tank Auth library is loaded to the new library

1. Add a group/roles column to the users table in the database

This can be done using phpMyAdmin or whatever MySQL client you use.

You can run the following SQL code

This will add a ‘group_id’ column to users and give every user a default value of ’300′

2. Create a library in CodeIgniter that extends Tank Auth with groups/roles support

(View code on github)
Here we will extend the ‘Tank_auth’ class, adding functions ‘is_group_member’ and ‘is_admin’. We will also override the ‘login’ function so we can add the ‘group_id’ to the CodeIgniter session after we login. Having ‘group_id’ in the session is necessary for the ‘is_group_member’ and ‘is_admin’ methods to work.

3. Create a model in CodeIgniter that extends the Tank Auth ‘users.php’ model

(View code on github)
Here we are extending the ‘Users’ model class simply to add a function allowing us to set the group ID in code. Every user is ’300′ by default and this function can be used to change the users group within your app.

4. Change everywhere the Tank Auth library is loaded to the new library

This step is the only modification necessary to make all the previous changes in your app take effect. Find everywhere in your CodeIgniter app that you are loading ‘tank_auth’ …

$this->load->library('tank_auth');
		

Out of the box, Tank Auth only loads the ‘tank_auth’ library in one place, which is in the ‘Auth’ controller.

Note about the admin group

The ‘admin’ group ID is hard coded as ’100′. When setting up your app, you can manually modify a user, giving them a group ID of ’100′ to make them an admin. Then you could code an admin panel and give admins the ability to give users a group ID of ’100′ or any other group (using the ‘set_group_id’ function added in step 3).

Download and install

With this download (tank_auth_groups.zip) you can simple copy the files into your existing Tank Auth install on CodeIgniter. Then you will need to apply steps 1 and 4 to your project. From there you can code you’re app with this minimal groups support.

Code

The code is hosted on github and I’ll keep this blog post in sync with the blogpost branch of the git repository.

Conclusion

Tank Auth is a rock solid CodeIgniter authentication library. In this post we’ve gone over an approach to extend Tank Auth to add groups/roles and admin support. This extension was created with the goal of being as minimal as possible and not modifying any existing Tank Auth code if possible. By applying object oriented clean code principles to this extension we’ve been able to do pretty well to meet the goals in creating this extension.

Additional Resources

Admin base class:

<?php

// application/controllers/admin_base.php

class Admin_Base extends CI_Controller {
    
   function __construct()
   {
      parent::__construct();
                
      $this->load->library(
         'tank_auth_groups', '', 'tank_auth'
      );
                
      if(!$this->tank_auth->is_admin())
      {
         redirect('auth/login');
      }
   }
} 

?>

Also

Ion Auth by Ben Edmunds is a popular CodeIgniter authentication library. I haven’t used it myself yet, but it does seem to offer significant groups, roles, admins etc features out of the box. It is also being actively developed (at of the time of writing). Definitely worth looking into.

I’ve had a Kinect for a few weeks now and I’m very pleased with my purchase. The experience of controller-less navigation through the UI menus and playing of games is a very welcome addition to interacting with a computer.

The Xbox 360 overall has turned out to be a great platform. With Xbox Live I can download a bunch of game demos for free and buy full games downloaded and stored on the Xbox memory so I can play these games/demos without a disk. Also, the Xbox 360 is rumored to become a home online media hub to compete with Google TV, Apple TV, Boxee etc. If this does happen, then the total of Kinect + Xbox Games + Xbox Online Media sounds like a sure winner to me, offering more than the competition.

Kinect is also in direct competition to the Nintendo Wii, and it has a lot of advantages over it. As an owner of both, I’ve been able to compare them from my own experience. While the Wii does offer some great family friendly fun with it’s simple standard games, I can see Xbox Kinect is going to take over where the Wii leaves off.

There are so many nice things about the controller-less experience of the Kinect. Using your full body in games is a fun and active workout as opposed to standard video gaming. You really need to try it out for yourself, it can really get you immersed in the game and it’s a lot of fun with two players. When you play with a group, it’s so nice to be able to just jump right in and start playing. I’ve had groups of ten or more over when we’ve played the Wii. It was a lot of fun, but the passing of the controller, putting on and removing the wrist strap and switching characters sometimes slowed things down. It wasn’t a big problem at all, but when compared to just walking in and out of game play, you notice how convenient the Kinect is.

I don’t always buy the newest gadgets when they come out (in fact my cell phone is still an iPhone 3G) but the Kinect is a product I recognized as truly a step forward in retail technology. It’s truly a step forward in human computer interaction that is available to everyone. I’ve been very pleased with my purchase. So far I’ve purchased the Kinect and games/accessories below (I also have an epson projector which makes it about 10 ft. on my wall, it’s very nice). I’ve already had a lot of fun testing these out. I’m looking forward to having a larger group of friends over to try it out with everyone. Lots of fun and cool new technology!

I see this as the beginning of much more than just new technology in gaming.

[This article ponders just a small bit of the pros and cons concerning Net Neutrality. Understand that I'm absolutely pro Net Neutrality as a policy, but I'm a bit divided on whether or not government should impose regulations to protect Net Neutrality. In the end, it seems like government regulations may be absolutely necessary to protect Net Neutrality, but whether the government will decide to regulate is another issue. Considering all this, Net Neutrality could be a potentially sticky issue for some time to come.]

My simple definition of Net Neutrality is…

“ISPs don’t touch the bits and bytes flowing through their pipes”

In other words, ISPs (Internet Service Providers) remain neutral concerning what internet traffic flows through their networks (or their “pipes”). ISPs just provide dumb pipes for the traffic to flow through. They remain neutral by not actively doing anything to the traffic, like filtering it or blocking it in any way. This is the way the internet has operated since it’s beginning (for the most part).

An example where an ISP acted in a non neutral way is when Comcast actively blocked BitTorrent traffic on its networks. In many ways, this is a fairly small thing they did. All paying customers of Comcast who did not use BitTorrent didn’t notice a thing. Comcast+BitTorrent users on the other hand, we’re stuck and would have been forced to switch ISPs in order to continue using BitTorrent, had the FCC not intervened.

This is small potatoes in comparison to what could be done by a non neutral ISP. Potentially, ISPs could exclude entire websites and networks of websites. They could offer preferred and speedier access to partnering digital media and news outlets. They could do a lot of potentially scary things. By controlling the network in such ways, ISPs could drastically change the internet as we know it to the extent that the network they offer could no longer truly be called “the internet”.

On the other hand, the ISPs own the pipes and who is to stop them from being non neutral? In the Comcast case, the FCC tried to stop them but in April 2010 it’s case was tossed by a federal court…

The question before the court was whether the FCC had the legal authority to “regulate an Internet service provider’s network management practice.” According to a three-judge panel, “the Commission has failed to make that showing” and the FCC’s order against Comcast is tossed.

In many ways this outcome is fair. If Comcast owns the pipes, who is to tell them what they can and can’t do with them? Or who should tell them what services they can and can’t offer? In a capitalist economy, shouldn’t the free market dictate that? Wouldn’t this cause competing ISPs to offer faster and better products? If their service is too restrictive, customers will go elsewhere right? Can’t the free market and net neutrality co-exist without outside regulation?

In an ideal world the free market should provide a lot of natural regulation, but in reality, it doesn’t always provide enough. I’m reminded of Allen Greenspan’s words concerning the 2008 economic downturn…

Mr. Greenspan said he made “a mistake” in his hands-off regulatory philosophy, which many now blame in part for sparking the global economic troubles. He quoted something he had written in March: “Those of us who have looked to the self-interest of lending institutions to protect shareholder’s equity (myself especially) are in a state of shocked disbelief.” – WSJ

He was shocked that lending institutions didn’t regulate themselves in their own self-interest and the interest of their share holders. My point is that sometimes, regulation is necessary. Net Neutrality regulations may very well be necessary to keep the internet the same open place we know it as today.

But the internet and it’s openness has also created a lot of new issues. The impact of the internet on the world is huge and while it has solved many problems and made things possible that were previously impossible, it has also created new problems. For instance, BitTorrent is commonly used to distribute pirated software, music, movies and more. Pirating software is a lot like stealing, except by making a copy of something, no physical good has been stolen. The main violation is that the creators of the pirated media don’t get any credit for the pirated copy. Don’t the creators have a right to some compensation or royalties for their work? Of course they do, but everybody knows you can pirate it on BitTorrent for free. Who is losing here? We all are to some degree, but most obviously it’s the creators of the work who are losing the most.

So maybe BitTorrent should be blocked. But of course there are other ways to share pirated copies on the internet. Potentially a non neutral ISP might have strong anti piracy policies active in their network. They might also be in partnership with music, media and software companies to provide a convenient solution to paying for digital products. Much like Apples iTunes and App Store. It seems if paying for digital products was easier than pirating them, most people would pay. I also believe that most people would want to pay and make sure the creators of media get paid for their work rather than pirate it.

In Conclusion (I need to wrap this up)
The neutral internet is and has been a means for the little guy to actually compete with major players on this “world is flat” playing field. In turn this has sparked much innovation in technology and brought many benefits and progression. On the other hand some “walled garden” approaches to internet software have proved beneficial for the mainstream (Apple and Facebook?) , arguably helping mainstream users to reduce the information overload that is a side affect of the open and neutral internet. But “walled garden” control at a network level would drastically change the entire foundation of the internet. It’s really scary to think of an internet in any other form than the neutral one we’ve come to know.

A few days ago an analogy regarding social networks and their future crossed my mind. The analogy is “The Digital Home” as a distributed social network platform.

The idea is that big social networks are kind of like massive communes where you have your own room (for instance my room on twitter is http://twitter.com/wrightlabs). You operate on these social networks primarily on their terms. As we’ve seen with Facebook, changing privacy policies and settings on their site, they have the ultimate say in how the platform changes and what you can and can’t do. Leadership in how you “live” on Facebook (and other social networks) is centralized and decided by Facebook management. Another thing about big social networks is that, once you are on it, you are limited to that one social network. If you sign up for Facebook, you can’t interact with your friend who is on Twitter and vice versa. Unless you have an account with both networks and then hook up some kind of connection, but even then it’s too cumbersome and probably wouldn’t work that well. You really need to be part of the same network or “commune” to network and interact.

But the “digital home” idea decentralizes all this, instead of you being a part of a commune living within it’s walls, you own your own home (or site). This home would in most cases be your own domain name (I plan to make mine http://ijohnwright.com). Similar to how you don’t allow just anyone into your physical home, you would have privacy controls to keep strangers out of your “digital home” or allow people in to certain rooms. If you have family/friends that would like a room in your “digital home” you could give them one if you choose so it may not just be you living at your home (which is essentially your domain name).

The benefit is that you own it all, but with all this comes the responsibility of maintaining a home. Paying the hosting bill, if/when the site goes down, running in and fixing it etc.

If your home is on one domain name, then this “digital home” will need a way to communicate with other similar homes on the web to be a “distributed social network”. I mean if my friend on another site updates his “room” that I have access to with some pictures, it needs to show up in my stream. If I can only see whats going on and interact within my digital home, then it’s not a distributed social network. So we’ll need a distributed social network platform or open protocol that all these digital houses use to connect together. There are already many technologies that could be used to achieve what I’m describing. It would take packaging them together or reinventing them into an Open Social protocol (I’m not referring to Google’s).

Apparently I’m not the only one who has been thinking along these lines.

Since I first started thinking this, we’ve seen Diaspora launch in a rather historic fashion. The fact that some dudes about to graduate from NYU can kickstart their career in such a fashion is evidence that a lot of other people are embracing the distributed social network concept as well.

Also, I just heard Matt of WordPress giving a similar analogy while being interviewed by the Scoblizer at Big Omaha. I’m glad to hear Matt is thinking like this because when I originally came up with the idea, Matt’s WordPress software is what initially came to mind.

Doing a little bit of searching for this I found the DiSo Project which I’ve heard of years ago through Chris Messina. Now I know exactly what DiSo is

So I guess the distributed social network idea is nothing new but maybe now it will really start to gain some traction. It’s good to know many are working on this. I think the project that will win the most adoption is the one that makes it simple and straight forward concerning privacy and how to set it up. These are two big challenges but I’m sure someone will solve them.

SPARQL allows you to query a semantic web (i.e. RDF) data source. This post will cover some basics of SPARQL but it will mainly focus on how to run a SPARQL query in code, against a SPARQL endpoint live on the web. The code I’m using is PHP and JSON but the overall steps are the same using any language.

(Here is the tutorial demo and the full source code for this tutorial.)

The overall steps are…

1. Constructing our SPARQL query
2. Preparing our REST URL
3. Make the HTTP request to the URL
4. Parsing the response
5. Use/Display the results

1. Constructing our SPARQL query

Our example SPARQL query will get the “abstract” section (i.e. brief description) of the RDF page for Honda Legend (http://dbpedia.org/page/Honda_Legend) in DBPedia

PREFIX dbp: <http://dbpedia.org/resource/>
PREFIX dbp2: <http://dbpedia.org/ontology/>
 
SELECT ?abstract
WHERE {
     dbp:Honda_Legend dbp2:abstract ?abstract . 
     FILTER langMatches(lang(?abstract), 'en')
}

(See this query run in DBPedia)

In the SPARQL query, ?abstract is a variable. The name is arbitrary (it could be called ?x) and all variables in SPARQL start with the ? (question mark).

The first line in the WHERE clause is a RDF triple. It’s a “subject predicate object” followed by a dot to end the triple (like the period of a sentence).

In this triple, the subject is dbp:Honda_Legend in it’s abbreviated form. We could also use it’s fully expanded form…
<http://dbpedia.org/resource/Honda_Legend>
and we wouldn’t need to have the PREFIX dbp: <http://dbpedia.org/resource/> line in the query.

The predicate is dbp2:abstract in it’s abbreviated form. The predicate in a triple describes the relationship between the subject and the object.

The object in this triple is the variable ?abstract. Or in other words, the object is what we are trying to find with this query.

To explain this query in English one could say “find the value of the object of the triple that matches the pattern “dbp:Honda_Legend dbp2:abstract object”

The second line in the WHERE clause is applying a filter to the results to only show the english version of the abstract.

Try these links for more info on the SPARQL query language.

SPARQL by example – Cambridge Semantics

SPARQL Tutorial

2. Preparing our REST URL

The URL we’ll send our request to will start with the SPARQL endpoint. For DBPedia it’s http://dbpedia.org/sparql and we’ll pass it some query string parameters, format and query (which is our SPARQL query).

function getUrlDbpediaAbstract($term)
{
   $format = 'json';
 
   $query = 
   "PREFIX dbp: <http://dbpedia.org/resource/>
   PREFIX dbp2: <http://dbpedia.org/ontology/>
 
   SELECT ?abstract
   WHERE {
      dbp:".$term." dbp2:abstract ?abstract . 
      FILTER langMatches(lang(?abstract), 'en')
   }";
 
   $searchUrl = 'http://dbpedia.org/sparql?'
      .'query='.urlencode($query)
      .'&format='.$format;
 
   return $searchUrl;
}

I’ve taken it a step further by creating this function getUrlDbpediaAbstract which takes a parameter $term that lets us plug in any DBPedia (also Wikipedia) page name to get the abstract for. (Note: $term must be an actual page name from DBPedia/Wikipedia so that the URL http://en.wikipedia.org/wiki/[page name] returns a non redirected Wikipedia article. The [page name] must be exact and it is case sensitive.)

The following approach to getting and using the data from this REST web service can be used for any REST web service that returns JSON as a response format. I’ve found this approach to be very simple and powerful. (I may write a separate post focusing on this approach).

3. Make the HTTP request to the URL

Making HTTP requests in PHP is pretty standard and easy task using cURL if you have it installed on Apache (which most web hosts do it seems). There is also a PEAR package HTTP_Request2 which is another option but it requires PEAR to be installed.

function request($url){
 
   // is curl installed?
   if (!function_exists('curl_init')){ 
      die('CURL is not installed!');
   }
 
   // get curl handle
   $ch= curl_init();
 
   // set request url
   curl_setopt($ch, 
      CURLOPT_URL, 
      $url);
 
   // return response, don't print/echo
   curl_setopt($ch, 
      CURLOPT_RETURNTRANSFER, 
      true);
 
   /*
   Here you find more options for curl:
   http://www.php.net/curl_setopt
   */		
 
   $response = curl_exec($ch);
 
   curl_close($ch);
 
   return $response;
}

Above is a simple function request which will request our the $url and return the response body as a string.

4. Parsing the response

The request to our URL above will return a string of JSON data because that’s the format we specified. I chose JSON as the response format because there is a very easy way to parse a JSON string in PHP 5. We can simply use json_decode . json_decode has a bool parameter assoc which if set to true returns a PHP array. With this PHP array we can easily access all the data returned in our response. We’ll see how easy this is in the next section.

5. Use/Display the results

With our results in a PHP array, we can use a little function that I created to neatly print the contents of a PHP array called printArray.

function printArray($array, $spaces = "")
{
   $retValue = "";
 
   if(is_array($array))
   {	
      $spaces = $spaces
         ."     ";
 
      $retValue = $retValue."<br/>";
 
      foreach(array_keys($array) as $key)
      {
         $retValue = $retValue.$spaces
            ."<strong>".$key."</strong>"
            .printArray($array[$key], 
               $spaces);
      }		
      $spaces = substr($spaces, 0, -30);
   }
   else $retValue = 
      $retValue." - ".$array."<br/>";
 
   return $retValue;
}

This function can be used in development to see where the data you want is located in the array.

Putting our functions together now we can display and use the data returned.

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

<?php 
$term = "Honda_Legend";
 
$requestURL = getUrlDbpediaAbstract($term);
 
$responseArray = json_decode(
   request($requestURL),
   true); 
?>
 
<h1>DBPedia Abstract for 
<?php echo $term ?></h1>
 
<h3>Request URL:</h3>
<?php echo $requestURL ?>
<br/>
 
<h3>Parsed Response: </h3>
<?php echo printArray($responseArray); ?>
<br/>
 
<h3>Abstract: </h3>
<?php echo $responseArray["results"]
    ["bindings"][0]
    ["abstract"]["value"] ?>

(See this run live or check out the full example source code on GitHub)

At the time of writing the results of
echo printArray($responseArray);
look like this…

     head
          link
          vars
               0 – abstract
     results
          distinct –
          ordered – 1
          bindings
               0
                    abstract
                         type – literal
                         xml:lang – en
                         value – The Honda Legend is a Mid-size luxury car made by the Japanese automaker Honda. It was originally developed as part of Project XX, a joint venture with the Austin Rover Group of Great Britain and was a twin of the Rover 800 series. The Legend was initially a four-door sedan, with a two-door coupé added later. It was the model which launched Honda’s upscale Acura brand in the United States. Honda was inspired by the word “legend” to create the first Honda vehicle with a V6. The first and second-generation Honda Legend was known as the Acura Legend in North American markets from 1986-1995, and in 1996 the third-generation was renamed as the Acura RL, while the Legend name is still used in Japan and other markets. Honda introduced the Legend as a flagship sedan to compete with the JDM Nissan Cedric and Nissan Gloria twins, the Toyota Crown, and later the Mazda Luce, and Mitsubishi Debonair. Unlike the Nissan twins and the Crown, the Legend is not used for taxi service. In the USA, the Legend competed with larger rear wheel drive V8 sedans Lexus LS and the Infiniti Q45, however, the Legend was marketed towards the slightly smaller Executive car vehicles that include the BMW 5 series, Audi A6, Mercedes-Benz E-Class, and the Jaguar S-type. The Legend hardtop coupe was introduced to compete with the Nissan Leopard coupe, the Toyota Soarer, and Mazda Cosmo.

From this we can discover the path to get the abstract data we want, which is…

<h3>Abstract: </h3>
<?php echo $responseArray["results"]
    ["bindings"][0]
    ["abstract"]["value"] ?>

from the code block above (line 22).

Conclusion

In this tutorial we’ve seen how to construct a SPARQL query that gets the value of the abstract property of DBPedia page. We sent the query to a SPARQL endpoint (DBPedia) which is a REST web service URI. We have parsed the results by converting the JSON string response to a PHP array using json_decode. This approach to consuming REST based web services is an easy way to access the data in the results. I may write a future post focusing on it.

A working demo of this tutorial is here and the full source code for the demo is on GitHub.

If you have any questions or issues with this tutorial and/or demo source code, please leave them in the comments below.