12:25 < Fuel-Bot> [oil] philsturgeon pushed 2 new commits to master: https://github.com/fuel/oil/compare/a8e1387…4be84aa                                                   eighty4
12:25 < Fuel-Bot> [oil/master] Making more use of the Form::label() in the scaffold builds – Adam Barrett                                                                    el2ro
12:25 < Fuel-Bot> [oil/master] Merge pull request #18 from utahcon/master – Phil Sturgeon

Today at 12:25MST my pull request for Oil was merged into the master line, which means it is gold!

$geekScore++;

From FuelPHP.com:

Fuel is a simple, flexible, community driven PHP 5.3 web framework based on the best ideas of other frameworks with a fresh start.

How much clearer can they get?

The Geeks Behind FuelPHP

Dan Horrigan, Phil Sturgeon, Jelmer Schreuder and Harro Verton. If those names mean nothing to you, let me shed some light.

Dan Horrigan

Coding in PHP for 10+ years Dan has contributed to projects like CodeIgniter and PyroCMS, as well as PancakeApp.

Phil Sturgeon

Another great mind behind CodeIgniter. Just look at Phil’s blog, he has done it all!

Jelmer Schreuder

Look through Jelmer’s Github and you can see he is quite experienced as well. He is also super friend in the #fuelphp channel on Freenode.

Harro Verton aka WanWizard

After a long and sordid past as a mainframer he has found roots in programming and contributes a lot of support in #fuelphp as well. He has personally helped me through some of the beginning steps of using FuelPHP.

To all the geeks involved in FuelPHP, a huge thanks!

What Make Fuel Different?

Fuel is young, under a year as of this writing, but already it has seen support and contributions from 30+ developers. The maintainers are really open to anyone committing code cause they believe that since we all use it, we all deserve to support it. Or something like that. Basically if you use it and identify a bug, and you can fix it, then they will let you.

That is probably the best thing about this young framework is the amount of involvement everyone has. Being open source and hosted on GitHub anyone can get the source, and anyone can submit a pull request for changes to the code. I have personally been watching the commits in the IRC channel and I can attest that they are sincere in saying that things are getting done. And fast!

What Make Fuel Awesome?

Gleaming from other great frameworks (and languages) Fuel has been given some great tools. Like Oil.

Oil

Oil is a utility for the CLI that allows you to Generate code, Refine (run tasks, more on this later),  Package (install, update and remove packages) and Console (test code).

Tasks

Tasks are classes that can be run through the command line or set up as a cron job. They are generally used for background processes, timed tasks and maintenance tasks. Tasks can calls models and other classes just like controllers.

Because Tasks actually use the whole framework you can write scripts using the native language of FuelPHP and all things work. All the controllers, all the helpers etc are available to the user.

Lightweight

Autoloading is fun, and useful, but you don’t want to load everything everywhere. Fuel has an extensive (and configurable) configuration to allow you to only load what you want when you want.

Docs

The documentation is a ongoing project, and no where near perfect right now, but it certainly is coming along. Don’t take that to mean it isn’t helpful, cause it absolutely is! Also you can update the docs and commit the changes to the project

ORM and Active Record or just DB

ORM has been done, and done again. FuelPHP has an ORM, or you can opt for ActiveRecord, or if you don’t like either of those you can just use good old SQL. Fuel is flexible and this is a great example of how flexible they really are.

Why Not?!

If you haven’t been sold by my simple blog post on Fuel, then perhaps you need to play with the framework yourself. You can get it from http://fuelphp.com or  from GitHub.

What’s Next?

I am working on a series of blog posts showing how to do things with FuelPHP, so keep tuned for those.

/**
 * DateTime settings
 *
 * server_gmt_offset    in seconds the server offset from gmt timestamp when time() is used
 * default_timezone        optional, if you want to change the server's default timezone
 */
'server_gmt_offset'    => 0,
 'default_timezone'    => 'America/Denver'

I have already set these to my local timezone of  ‘America/Denver’ but you can simply comment them out and the default from your php.ini will take effect.

What are Hooks?

I’m going to let the folks at Code Igniter field this one:

CodeIgniter’s Hooks feature provides a means to tap into and modify the inner workings of the framework without hacking the core files. When CodeIgniter runs it follows a specific execution process, diagramed in the Application Flow page. There may be instances, however, where you’d like to cause some action to take place at a particular stage in the execution process. For example, you might want to run a script right before your controllers get loaded, or right after, or you might want to trigger one of your own scripts in some other location.

So to clear that up, Hooks let you change the way Code Igniter works, without changing Code Igniter.

10K ft view:

So the problem I had recently was a page that loads a CSS class only when the user selects to change the theme. However it had to be done through a link and had to set the preference in the session to be stored throughout the users session.

To accomplish that I had planned to create a simple controller action called setCssTheme and pass the theme the user had selected. The only problem was I needed to send the user back to the page they had come from, and in some cases the referrer was not being set (different browsers handle things differently).

In order to solve this last problem I had decided to set in the session the last page visited on each page load. This works great in a constructor of a particular class but what if you want to do that site wide, on every single page load like I do?

Force all your site through a single controller? I think not.

Force all your controllers to have this same piece of code? I think not.

Let’s get DRY (Don’t Repeat Yourself).

The solution I decided on was using Hooks in Code Igniter to Hook the system process and set in the session the current page I am on. In order to be able to do this I have to be able to write to the session before the headers are sent to the browser, and so I had to choose the appropriate hook point. CI gives you the follow points to hook in:

• pre_system
  Called very early during system execution. Only the benchmark and hooks class have been loaded at this point. No routing or other processes have happened.
• pre_controller
  Called immediately prior to any of your controllers being called. All base classes, routing, and security checks have been done.
• post_controller_constructor
  Called immediately after your controller is instantiated, but prior to any method calls happening.
• post_controller
  Called immediately after your controller is fully executed.
• display_override
  Overrides the _display() function, used to send the finalized page to the web browser at the end of system execution. This permits you to use your own display methodology. Note that you will need to reference the CI superobject with $this->CI =& get_instance() and then the finalized data will be available by calling $this->CI->output->get_output()
• cache_override
  Enables you to call your own function instead of the _display_cache() function in the output class. This permits you to use your own cache display mechanism.
• post_system
  Called after the final rendered page is sent to the browser, at the end of system execution after the finalized data is sent to the browser

From those you can see the logic answer is to hook the post_controller so that our controller has a chance to do it’s work, and then to hack in out changes for the session, in this case add data to it.

How To:

Time to put rubber to the road, here is what I had to do to accomplish this task:

1. Enable Hooks
2. Configure Hook
3. Write Hook

Enable Hooks:

To enable the hooks you simply edit

application/config/config.php

and find the line:

$config['enable_hooks'] = false;

and change it to:

$config['enable_hooks'] = TRUE;

Configure Hook:

Now in application/config/hooks.php you need to tell the system what file path, file, controller, method, and parameters you want to run on the hook.

$hook['post_controller'] = array(
  'filepath' => 'hooks',
  'filename' => 'SessionHelper.php',
  'class' => 'SessionHelper',
  'function' => 'setCurrentPage',
  'params' => array(),
);

Here I tell CI that when the controller is done, load hooks/SessionHelper.php and fire off SessionHelper->setCurrentPage() (more or less).

Then I created the file mentioned above as follows:

class SessionHelper extends CI_Hooks {
  public $CI;

  function __construct() {
    parent::__construct();
    $this->CI = get_instance();
  }

  function setCurrentPage(){
    $this->CI->session->set_userdata('current_page', current_url());
  }

This simply loads the current_url() into the session userdata.

Now on every final page load (redirects won’t be caught if they are in the controller) the current_url is stored in the session. So I can check values and redirect back to the current page if needed.

I have been using jQuery both professionally and personally for about a year now but this book still brought a lot to the table.

Earle Castedine and Craig Sharkie have a great sense of humor, and obviously know their way around jQuery, CSS, HTML and the likes. The book uses some real world examples of creating image galleries and user interfaces. They break down the jQuery code to it’s basic forms, and then explain why things work the way they do. They don’t get too deep into Javascript except to note that jQuery is nothing more than a fancy framework on top of Javascript and uses Javascript for everything! I thought it particularly neat when they would show the “hard” way to do things, then the better way to do them, and then finally a plugin that made all the work you had just done seem useless, but it isn’t useless because you now understand how the plugin works better than if you had just slapped it in place in the beginning.

The book is quite deep about animations, AJAX actions, DOM manipulation and the sort. Even if you know Javascript and you have been using jQuery there is something in here that will make you go “ah ha!”.

To the folks over at SitePoint (an O’reilly company) good work!

The past few months have kept myself and my team quite busy, as we’ve turned our attentions from maintenance of the Zend Framework 1.X series to Zend Framework 2.0. I’ve been fielding questions regularly about ZF2 lately, and felt it was time to talk about the roadmap for ZF2, what we’ve done so far, and how the community can help.

He goes on to talk about the processes being taken to get Zf2.0 the exemplar of PHP 5.3 and to add namespaces to the project. He talks about his team, the road map and the struggles they have already expereienced:

After completing this process, my entire team — all three of us — started the work of migrating the code to namespaces. Ralph wrote a tool that scanned the library and created a map file of existing classes and suggested namespace/classname combinations. We then used this tool as a launching point for the migration, each of us working on a component at a time. This work was by no means automated — we discovered very quickly that such a tool only took care of the most cursory work. I detailed some of our findings a couple months back; we ran into a number of issues we never anticipated, and the progress has been far from speedy. At this point, however, we have migrated everything but theZend_Service classes, the MVC, and those components that build on top of the MVC (Application, Navigation, Form, etc.).

Finally he shares details about getting ZF2.0 available through Git and Github, and what the community can do to help:

A number of contributors are also starting to discuss rewrites and refactoring of components. Much of this is being done on the zf-contributors mailing list, and some on the #zftalk.dev channel on Freenode. If you are interested in contributing, I highly recommend subscribing to the list and dropping into the channel when you can.

You can read the post in it’s entirety at  http://weierophinney.net

Ceiling Cat

Ceiling Cat announces:

#hackUTOS is is happening tomorrow, Friday June 4th, at CoffeeConnection!

Here’s how it works. #hackUTOS is a gathering of the hacking inclined. There is a main project (ConMan) that is being hacked on for the purpose of volunteering for Utah Open Source Conference 2010. More details on ConMan in a minute.

If you are looking to generally gather with geeks then this is the premier event in June for your geekiness! We will be gathering at CoffeeConnection who has great caffeinated beverages for sale (as well as food) and we will be getting our Geek on.

Want to get your geek on, but can’t make it in person… we are going to be on IRC too! Find us on Freenode at #hackUTOS

If you are not interested in hacking on ConMan, we still encourage you to come on down! We want all geeks to come by and share in the glory of #hackUTOS. That means you can even bring your own project. Think of #hackUTOS as a Jelly or CoWork (for 1 night). Come share your project and your ideas, find people, network, and generally have a good time.

Now some details on ConMan!

ConMan is the Conference Management software used by UTOS for the UTOS Conference. It is written in Python, using the Django framework. It is hosted at GitHub and it is open to the public. If you don’t hack python do not turn and run just yet. We are in need of things besides python coding. We need folks who are willing to conceptualize, we need graphic designers to help make the app look pretty, we need people to help with bug reporting, and more. If you are reading this blog post you are more than qualified to come help us tomorrow (and at any other #hackUTOS event).

Alright… I am tired of typing, and Ceiling cat is starting to freak me out… see you at #hackUTOS

Meet at the nearest location to you at 12:30pm this Friday, February 26, 2010.  If you have never been, look for the group with this logo at their table.  Geek Lunch is organized by the Utah Open Source Foundation, but you must pay for your meal.  We look forward to seeing all of you there.

When:

Date: Friday,February 26, 2010
Time: 12:30pm – 2:00pm

Where:

We have geeks all over Utah, and as such we like to spread the love to more than just 1 pub, so we have two (because Utah county is slacking) locations to choose from.

Salt Lake County
The Green Pig
31 East 400 South
Salt Lake City, Utah 84111
Website: http://www.thegreenpigpub.com/
Map: http://snipr.com/uhhox
Phone: (801) 532-7441

Weber / Davis Counties
Roosters
748 Heritage Park Boulevard
Layton, Utah 84041
Website: http://roostersbrewingco.com/
Map: http://snipr.com/uhizp
Phone: (801) 774-9330

Utah County
There is currently no place planned for in Utah county due to low turnout.  If you would like to help organize a Geek Lunch in Utah county, please email clint@utos.org.

ConMan Hack Night

Did you attend UTOSC last year? Are you going to attend this year? Did you like how the process to register and attend was super easy? That is all thanks to ConMan, the Conference Management software that the Utah Open Source Foundation created, and maintains.

If you want to make sure things stay smooth at the conference, and participate in an open source project then you are invited to come down and help us code the project to the next milestone!

Where:

Salt Lake Coffee Connection

1588 South State Street, Salt Lake City UT

Directions

When: 7pm – ??

You see the ?? means you can come and code as late as you want! The coffee house is open really late, and you are welcome to stay and code till they kick you out!

What:

So we get together each week to work on the project, cause we think ConMan can be the best conference management software ever! We simply would love to have some more people who love open source, and know python and django come down and contribute to the code base!

When you instantiate a PHP Soap Class you pass it a WSDL (Web Services Description Language) and it looks like this:

$client = new SoapClient('http://example.com/services/thescript.php?wsdl');

Depending on how your caching is setup, this will go out to the WSDL provided, pull in the document and store it in a cache. The default cache for PHP is 86400 seconds. If you are familiar with time in seconds you know that that is 24 hours. So by default you only actually read the WSDL once in a 24 hour period. Normally this is not a problem.

What is a WSDL?

For that answer let’s turn to the W3 site:

WSDL is an XML format for describing network services as a set of endpoints operating on messages containing either document-oriented or procedure-oriented information.

So in English that means it is a map to the services provided by the provider. Basically you get a copy of the map, and follow the endpoints to the answers you need.

One basic function of this is that it tells you want methods (services) are available on your fresh client.

When WSDLs go bad

So today one of my providers, without warning, updated their WSDL. This wreaked havoc on my system because I had cached the WSDL on my side for 24 hours (remember, the PHP default). The change was a super simple change, a change in URL for a service, that’s it!

The problem was that since PHP had already read the file within 24 hours it didn’t care that there was a new file, that the URLs had changed, and so it continued to work as it had before.

The real problem wasn’t that the URLs changed, that would have been fine if the provider hadn’t shut off the previously reported URLs.

Turn off the cache

So you are left with two options when something like this happens. First, you can sit and wait up to 24 hours for the problem to fix itself. This was not an option for us. The second is to clear your cache and try again.

Now PHP (on Linux) stores the cache for the Soap WSDL in /tmp and I wasn’t sure which one of the many files was the actual cache for this particular provider so I decided I would have to tell PHP to not cache the WSDL and try again.

Into php.ini I went, located the soap.wsdl_cache_enabled flag. I changed it from 0 to 1

soap.wsdl_cache_enabled=0

I saved the file and restarted Apache.

The service continued to fail. I was perplexed. I thought maybe I flubbed the save so I opened the php.ini again located my line and it was fine. So I looked around there to see if maybe I missed another important flag. The only thing I could find was soap.wsdl_cache_ttl listed as the “(time to live) Sets the number of second while cached file will be used instead of original one” I promptly changed this to 0 as well

soap.wsdl_cache_ttl=0

Restarted Apache, and finally my script stopped failing.

I have since re-enabled my cache ttl and enabled flags, as reading the WSDL every time is a resource hog that doesn’t need to be in place.

The Lesson Learned

The lesson learned by all today is be aware of your caching, and be aware of the changes you make to your live/production systems.

I can’t seem to find a call like josso_authenticate($name, $pass), returning an array to be appended to user’s SESSION. I was expecting such a method, because SOAP is already used everywhere, so it shouldn’t be too hard implementing this.

Has anyone had success implementing this kind of “transparent” login?

JOSSO simply doesn’t make it easy to log people in with a single call. Instead you need to make an interface to the API to do so. I just so happen to have an example of such a wrapper function.

Logging In A User

To do everything and make it easy for future reuse I built two classes. The first is a Login Class and the second a Josso Class (below). My Login Class is pretty sparse, but it includes a wrapper to handle all the tasks required to login a user through Josso and get back the Josso details for that user.

The full code of each class is down at the bottom of the post, just expand the code block, but here is the function that is really what you are looking for Login->authorize()

Login->authorize()

public function authorize($username, $password){

 # make sure we have a valid username
 if(empty($username)){
 # return invalid username
 throw new LoginException('Invalid username');
 } else {
 $this->username = $username;
 }

 # make sure we have a valid password
 if(empty($password)){
 # return invalid username
 throw new LoginException('Invalid password');
 }

 # check that user exists
 if( ! $this->josso->userExists($this->username)){
 throw new LoginException('Invalid username');
 }

 # check Josso with username and password
 $this->assertion = $this->josso->assertIdentityWithSimpleAuthentication($username, $password);
 if($this->josso->error){
 throw new LoginException('Invalid username/password combination');
 }

 # resolve Authentication Assertion
 $this->token = $this->josso->resolveAuthenticationAssertion($this->assertion);
 if($this->josso->error){
 throw new LoginException('Interal Error [Login]: '. __LINE__);
 }

 $this->session = $this->josso->getSession($this->token);
 if($this->josso->error){
 throw new LoginException('Interal Error [Login]: '. __LINE__);
 }

 $this->user = $this->josso->findUserInSession($this->token);
 if($this->josso->error){
 throw new LoginException('Interal Error [Login]: '. __LINE__);
 }

 $this->cleanUpUser();

 $this->roles = $this->josso->findRolesByUsername($this->username);
 if($this->josso->error){
 throw new LoginException('Interal Error [Login]: '. __LINE__);
 }

 $this->cleanUpRoles();

 $this->user->sosPermissions =& $this->roles;
 }

What That Actually Did

As you can see you simply pass the $username and $password to the function and it runs through a ton of work for you.

First it validates the input, make sure you aren’t working for no reason.

Next it makes sure the userExists(), this will save you heartache later when JOSSO pretends a user exists, but really doesn’t.

Then I asserIdentityWithSimpleAuthentication() which literally means I pass those to JOSSO and wait for an answer. The answer returned is an assertion_id, which really doesn’t mean anything.

You then take the assertion_id returned and call resolveAuthenticationAssertion(), this will return your session_id if the login was valid.

With the session_id you call getSession(). This returns all the details of the session that JOSSO now has open. This varies depending on who setup your JOSSO implementation but you should have an identifying is (user_id) if nothing else.

I go on to make sure that JOSSO hasn’t forgotten anything by calling findUserInSession(), which literally just tells me who I am supposed to be working with.

The cleanUpUser() you could probably ignore, but our system returns an object with dots ( . ) in the name and I can’t stand that, so I change them to underscores ( _ ).

Finally I call back to my JOSSO install to get any roles the user has, again this will vary if your JOSSO doesn’t handle roles.

Login Class

class Login {

 public $token;
 public $username;
 public $session;
 public $roles;
 public $user;
 public $request;
 private $assertion;
 # this will hold the instance of Josso Controller we need
 private $josso;

 function Login($request = null){

 $this->josso = new Josso;
 if(!empty($request)){
 $this->request = $request;
 }
 }

 #validate an existing token
 public function validateToken($user_token){
 $session = $this->josso->accessSession($user_token);

 /*
 * For whatever reason Josso returns nothing if the session is valid
 * and the operation has been completed.
 */
 if( empty($session)){
 return true;
 }

 if($this->josso->error){
 throw new LoginException('Internal Error [Login]: '. __LINE__);
 }
 return false;
 }

 # authorize a user with password
 public function authorize($username, $password){

 # make sure we have a valid username
 if(empty($username)){
 # return invalid username
 throw new LoginException('Invalid username');
 } else {
 $this->username = $username;
 }

 # make sure we have a valid password
 if(empty($password)){
 # return invalid username
 throw new LoginException('Invalid password');
 }

 # check that user exists
 if( ! $this->josso->userExists($this->username)){
 throw new LoginException('Invalid username');
 }

 # check Josso with username and password
 $this->assertion = $this->josso->assertIdentityWithSimpleAuthentication($username, $password);
 if($this->josso->error){
 throw new LoginException('Invalid username/password combination');
 }

 # resolve Authentication Assertion
 $this->token = $this->josso->resolveAuthenticationAssertion($this->assertion);
 if($this->josso->error){
 throw new LoginException('Interal Error [Login]: '. __LINE__);
 }

 $this->session = $this->josso->getSession($this->token);
 if($this->josso->error){
 throw new LoginException('Interal Error [Login]: '. __LINE__);
 }

 $this->user = $this->josso->findUserInSession($this->token);
 if($this->josso->error){
 throw new LoginException('Interal Error [Login]: '. __LINE__);
 }

 $this->cleanUpUser();

 $this->roles = $this->josso->findRolesByUsername($this->username);
 if($this->josso->error){
 throw new LoginException('Interal Error [Login]: '. __LINE__);
 }

 $this->cleanUpRoles();

 $this->user->sosPermissions =& $this->roles;
 }

 public function createLoginFromToken($token){

 $this->user = $this->josso->findUserInSession($token);
 if($this->josso->error){
 throw new LoginException('Interal Error [Login]: '. __LINE__);
 }

 $this->cleanUpUser();

 $this->roles = $this->josso->findRolesByUsername($this->user->name);
 if($this->josso->error){
 throw new LoginException('Interal Error [Login]: '. __LINE__);
 }

 $this->cleanUpRoles();

 $this->user->sosPermissions =& $this->roles;
 }

 # get a Josso hashed version of a password
 public function getPassHash($password){
 $passhash = $this->josso->getPassHash($password);
 return $passhash;
 }

 # acquire roles for the user from josso
 public function getUserRoles(){
 return $this->roles;
 }

 # send the signal to Josso to signoff (closes all sessions)
 public function signoff($session_id = null){
 if( ! $session_id && ! $this->session->id){
 return false;
 }

 if(!$session_id){
 if(!empty($this->session)){
 if($this->josso->globalSignoff($this->session->id)){
 return true;
 }
 } else {
 return false;
 }
 } else {
 if($this->josso->globalSignoff($session_id)){
 return true;
 }
 }
 return false;
 }

 private function cleanUpUser(){
 if(!empty($this->user)){
 foreach($this->user->properties as $prop => $details){
 $name = $details->name;
 if($pos = strpos($name, '.')){
 $name = explode('.',$name);
 $name = $name[0] . ucwords($name[1]);
 }
 $this->user->$name = $details->value;
 }
 unset($this->user->properties);
 }
 }

 private function cleanUpRoles(){
 if(!empty($this->roles)){
 foreach($this->roles as $key => $details){
 $tmpRoles[$key] = $details->name;
 }
 $this->roles = $tmpRoles;
 }
 }
}
?>

Josso Class

<pre>class Josso {

 var $SSOIdentityManager;
 var $SSOSessionManager;
 var $SSOIdentityProvider;
 var $JossoPashHash;
 var $error;

 function Josso(){

 // create the soapclients
 $this->SSOIdentityManager = new Soapclient(JOSSO_SERVER .'/josso/services/SSOIdentityManager?wsdl', array('Trace' => 1));
 $this->SSOSessionManager = new Soapclient(JOSSO_SERVER .'/josso/services/SSOSessionManager?wsdl', array('trace' => 1));
 $this->SSOIdentityProvider = new Soapclient(JOSSO_SERVER .'/josso/services/SSOIdentityProvider?wsdl', array('trace' => 1));
 }

 function accessSession($session_id){
 try{
 $accessSession = $this->SSOSessionManager->accessSession($session_id);
 // we expect a null
 return $accessSession;
 } catch(Exception $e){
 $this->error = $e;
 return false;
 }
 }

 // check if a user exists
 function userExists($username){
 try {
 $userExists = $this->SSOIdentityManager->userExists($username);
 return true;
 } catch (Exception $e){
 $this->error = $e;
 return false;
 }
 }

 // assert a login
 function assertIdentityWithSimpleAuthentication($username, $password){
 try{
 $loginAssertion = $this->SSOIdentityProvider->assertIdentityWithSimpleAuthentication($username, $password);
 return $loginAssertion;
 } catch (Exception $e){
 $this->error = $e;
 return false;
 }
 }

 // check assertion and get session
 function resolveAuthenticationAssertion($loginAssertion){
 try{
 $session = $this->SSOIdentityProvider->resolveAuthenticationAssertion($loginAssertion);
 return $session;
 } catch (Exception $e){
 $this->error = $e;
 return false;
 }
 }

 // get session details
 function getSession($session){
 try {
 $sessionDetails = $this->SSOSessionManager->getSession($session);
 return $sessionDetails;
 } catch (Exception $e){
 $this->error = $e;
 return false;
 }
 }

 // make sure the session we found belongs to our user
 function findUserInSession($session){
 try {
 $userInSession = $this->SSOIdentityManager->findUserInSession($session);
 return $userInSession;
 } catch (Exception $e){
 return false;
 }
 }

 // not used
 function findUser($username){
 try{
 $userDetails = $this->SSOIdentityManager->findUser($username);
 return $userDetails;
 } catch (Exception $e){
 return $e;
 }
 }

 // get a users roles
 function findRolesByUsername($username){
 try {
 $userRoles = $this->SSOIdentityManager->findRolesByUsername($username);
 return $userRoles;
 } catch (Exception $e){
 $this->error = $e;
 return false;
 }
 }

 function globalSignoff($session){
 try {
 $signoff = $this->SSOIdentityProvider->globalSignoff($session);
 } catch (Exception $e){
 $signoff = $e;
 }
 unset($_SESSION['josso']);
 return $signoff;
 }

 function getPassHash($password){
 try{
 $result = $this->JossoPashHash->hash($password);
 return $result;
 } catch (Exception $e){
 return $e;
 }
 }

}

That’s It!

I hope I have at least in part helped with your quest to make logging people in through JOSSO more bearable.