The solution:

<script type="text/javascript">
		$(function() {
		$('#long-text').scroll(function(e) {
			if(($(e.target).height() + e.target.scrollTop) == e.target.scrollHeight) {
				$('#submit').attr('disabled', false);
			}
		});
	});
</script>

Here is a working demonstration. This assumes that you utilize the jQuery library, otherwise there is not really a simple solution to detect scrolling at the DOM level.

The original function:

function authorizePHPSession(phpSessionId, cb) {
    try {
        fs.readFile('/path/to/sessions/sess_'+phpSessionId, 'utf8', function(err, data) {
            if(err) {
                throw err;
            }

            if(data.search(phpSessionId.toString()) > -1) {
                cb(null, true);
            } else {
                cb(null, false);
            }
        });
    } catch(e) {
        cb(null, false);
    }
}

Here is the new code:

function authorizePHPSession(data, cb) {
    var phpSessionId = getPHPSessionId(data.headers.cookie);
    dbClient.connect();
    dbClient.query(
        "SELECT * FROM `Sessions` WHERE data LIKE '%Zend_Auth|a:1:{s:7:\"storage\";s:%:\"%\";}%' AND `id` = ?",
        [phpSessionId],
        function(error, rows, fields) {
            if(error) {
                console.log('Error: ' +error);
                cb(null, false);
            } else {
                if(rows.length == 1) {
                    data.phpSessionId = phpSessionId.toString();
                    cb(null, true);
                } else {
                    cb(null, false);
                }
            }
        });
    dbClient.end();
}

This authorization check now access the Sessions table set up via Zend Framework, for more information in regards to moving session from the file level to the database level please check out this article: http://dionysus.uraganov.net/frameworks/zend-framework-storing-session-in-database/. The check makes two assumptions. One there is an “id” field in your table schema that matches the string in your headers/cookies. Second is the string it matches againnst the database entries. The web application uses the default Zend_Auth namespace so if there are customizations on this namespace the string will vary based on that customization.

One day while driving along a high way in Jersey City I passed the Hudson Dodge dealership. Something out of the ordinary caught my eye. Silver Charger with really big black rims… I pulled over into the visitor parking area and instantly fell in love. This car was immaculate. I mean it has everything found in the higher end V8 models and then some. A ridiculously loud sound system, huge wheels, the new 3.6L V6, and the new ZF 8-speed transmission. This new transmissions allows this car to have more bark than its bite. I spoke with the salesman briefly and asked about the sticker price, how much I can expect for a trade in with my Acura, and when I can test drive it.

I still have yet to test drive it due to time constraints but I did get a chance to sit in it and play with the interior. It is a step above anything I own and I look forward to getting one by the end of the year. Here is a quick picture that I snapped as I left the dealership.

This car is beautiful, I am in love again with a Dodge.

Lets say that you have three different database tables Users, Diets and Pets. These three tables represent objects that you can manipulate in your code, however there is no quick or easy method to deliver the boilerplate for these “models”. Given enough thought I came up with a base class and it looks something like this:

<?php
class Model {
    protected $_data = array();

    public function __get($name) {
        if(isset($this->_data[$name])) {
            return $this->_data[$name];
        }

        return null;
    }

    public function __set($name, $value) {
        $this->_data[$name] = $value;
    }

    public function toArray() {
        return $this->_data;
    }
}
?>

Seems pretty simple, fair enough. This code however goes a long way. Since the main data store in the class “_data” is kept protected we have no other way to access properties except the magic __get/__set methods. This can either be a blessing or a nightmare. If you do not have an IDE such as Netbeans or PhpStorm using annotations will not help you however if you do, then you are ahead of the game. Since this class is meant to be extended adding annotations to the base class is meaningless, however for the Pets class lets say it looks something like this:

<?php
/**
 * @property $user_id
 * @property $pet
 * @property $favorite
 */
class Application_Model_Pet extends Model {

}
?>

The annotations serve a dual purpose: 1.) If anyone looks at the source for this model they will know exactly how it works, 2.) If anyone has a ide capable of reading annotations you can rest assured that when you are working with the specified model you will be able to use code completion to the maximum (helps out when you are working with 300 models and forget exactly what property is a member of what class…). Now the second part of using the Data Mapper pattern is building a mapper class that will feed the data into the class as well as send it back to the database when you want to save it. This is pretty trivial if you are working with Zend Framework. Here is an example mapper class.

<?php
class Application_Model_PetMapper {
    protected $dbTable;
    private $ignoreProperties = array();

    public function setDbTable($dbTable) {
        if(is_string($dbTable)) {
            $dbTable = new $dbTable();
        }

        if(!$dbTable instanceof Zend_Db_Table_Abstract) {
            throw new Exception('Invalid table data gateway provided.');
        }

        $this->dbTable = $dbTable;
        return $this;
    }

    /**
     * @return Application_Model_DbTable_DietaryRestrictions
     */
    public function getDbTable() {
        if($this->dbTable === null) {
            $this->setDbTable('Application_Model_DbTable_Pets');
        }

        return $this->dbTable;
    }

    /**
     * @param $user_id
     * @param $pet
     * @return Application_Model_Pet|null
     */
    public function find($user_id,$pet) {
        $result = $this->getDbTable()->find($user_id, $pet);
        if(count($result) == 0) {
            return null;
        }
        $row = $result->current();
        $p = new Application_Model_Pet();
        foreach($row->toArray() as $k=>$v) {
            $p->$k = $v;
        }
        return $p;
    }

    /**
     * @param $column
     * @param $value
     * @return array|null
     */
    public function findBy($column, $value) {
        $result = $this->getDbTable()->fetchAll(array("$column = ?"=>$value));
        if(count($result) === 0) {
            return null;
        }

        $collection = array();
        foreach($result as $v) {
            $p = new Application_Model_Pet();
            $e = $v->toArray();
            foreach($e as $k=>$value) {
                $p->$k = $value;
            }
            $collection[] = $p;
        }
        return $collection;
    }

    public function save(Application_Model_Pet $p) {
        $data = $p->toArray();

        foreach($this->ignoreProperties as $property) {
            if(isset($data[$property])) {
                unset($data[$property]);
            }
        }

        $db = $this->getDbTable()->getAdapter();
        $sql = 'INSERT INTO
                        `Pets` (`user_id`, `pet`, `favorite`)
                    VALUES
                        (?,?,?)
                    ON DUPLICATE KEY UPDATE
                        `user_id`=`user_id`, `pet`=`pet`, `favorite`='.(int)$data['favorite'];
        $result = $db->query($sql, array((int)$data['user_id'], (int)$data['pet'], (int)$data['favorite']));
        return (bool)$result->rowCount();
    }

    public function delete(Application_Model_Pet $p) {
        if($p->user_id !== null && $p->pet !== null) {
            return (bool)$this->getDbTable()->delete(array('user_id = ?'=>(int)$p->user_id, 'pet = ?'=>(int)$p->pet));
        }

        return false;
    }
}
?>

Given enough time you can abstract away the mapper class and only have to provide a few initialization variables and everything else will take care of itself. In the end the Data Mapper pattern is not that bad and fits in quite nicely with Zend Framework. Other systems manage relationships for you but if you look at the Data Mapper pattern in detail adding that functionality into the mapper class itself should be trivial.

Edit:
Here is an additional thought on this pattern. The above mapper’s save function is built on specific schema that has two columns as primary keys. If you have just one column and the primary key’s identifier is “id”, here is what a mapper’s save function might look like:

    public function save(Application_Model_User $user) {
        $data = $user->toArray();

        foreach($this->ignoreProperties as $property) {
            if(isset($data[$property])) {
                unset($data[$property]);
            }
        }

        if(($id = $data['id']) !== null) {
            $this->getDbTable()->update($data, array('id = ?'=>(int)$id));
        } else {
            unset($data['id']);
            $user->id = $this->getDbTable()->insert($data);
        }
    }

As someone who is deeply entrenched in technology (I work at a startup in Manhattan) I would know your thoughts on PIPA and the Houses proposed SOPA bill.

One thing I find appalling is the lack of oversight with this bill. Why did not one House representative or Senator meet with major technology companies to discuss how to tackle this issue instead of blindly charging ahead? Is this the best solution? How is it that not even the Communications, Technology and Internet subcommittee was not even consulted? I am sure anyone familiar with how DNS works would have screamed “Fus Ro Dah” (based on a game I play, anyone familiar with the internet would get the joke) at any individual who mentioned a change such as that proposed in SOPA or PIPA.

I know there is a lot going on in the world right now, terrorism, threats of war, Iran, etc… But the basic tenants of freedom of speech must be preserved and it will only be a matter of time before the individuals who lobbied for this power begin to abuse it. “Power tends to corrupt, and absolute power corrupts absolutely. Great men are almost always bad men.” – Lord Acton

I am not a proponent of online piracy or advocate it in any way but this is not the proper solution to solving the issue. If the MPAA and the RIAA spent half as much time on developing strategies to adapt to the Internet as they have lobbying for change then we wouldn’t have these very dangerous bills up for consideration.

I look forward to your reply,
Warm Regards,
Anthony Wlodarski

——–
I implore you exercise your first amendment rights before they are gone. I don’t know if it is the crazy in me but it seems every day, more and more, the second amendment is needed to protect the rest of them from abuse and corruption. I just wish there was a better way.

So after scouring Newegg and local stores for many different deals that I slept on and hate myself for sleeping on till this day I decided to build a new machine.  The machine has to be able to handle the development tasks I throw at it as well as be able to play BF3 and Skyrim with the high and ultra settings I have been used too.  For a case I choose the venerable Antec Three Hundred.  For a motherboard I choose the Gigabyte Z68 UD3 chipset, very solid design.  For the processor I snagged a Intel i5-2500k for on the cheap which is a trust worthy CPU and can be easily over clocked.  I picked up a XFX AMD 6750 video card to hold me over till something better comes along and repurposed my existing 2TB of Sata hard drives.  All this is pulled together with 16GB of DDR3-1600 Kingston ram.  Here are some pictures of the build process that I took last night:

/** Require the http module. */
var http = require('http');
 
/** Create a new http server to listen to and send requsts from. */
var server = http.createServer(function(req, res) {
    res.writeHead(200, {'Content-Type':'text/html'});
    res.end();
});
server.listen(12121);
 
/** Require the socket.io module */
var io = require('socket.io').listen(server);
 
/** File system library **/
var fs = require('fs');
 
/** Extract the session id from the headers cookies **/
function getPHPSessionId(cookies) {
    var phpSessionId = '';
    cookies.split(';').forEach(function(a) {
        var b = a.split('=');
        if(b[0].trim() == 'PHPSESSID') {
            phpSessionId = b[1].trim();
        }
    });
 
    return phpSessionId;
}
 
/**
 * This function will look in the PHP Session directory and look for the session
 * file.  If the file exists it will load that file as a string and then parse
 * that string for the PHP Session which will only be stored once the PHP authorization
 * method saves it.
 */
function authorizePHPSession(phpSessionId, cb) {
    try {
        fs.readFile('/path/to/sessions/sess_'+phpSessionId, 'utf8', function(err, data) {
            if(err) {
                throw err;
            }
 
            if(data.search(phpSessionId.toString()) > -1) {
                cb(null, true);
            } else {
                cb(null, false);
            }
        });
    } catch(e) {
        cb(null, false);
    }
}
 
io.configure(function() {
    io.set('transports', ['xhr-polling','htmlfile','jsonp-polling']);
    io.set('authorization', function (data, cb) {
        authorizePHPSession(getPHPSessionId(data.headers.cookie), cb);
    });
});

As you can see here we have the usual Node.js lifting. We create a http server, we create an instance of the io object from Socket.io and get to it. However then we begin to get into the interesting functions. “getPHPSessionId” is a utility function that will parse the cookie information attached to the handshake data. If we find the correct cookie prefix (PHPSESSID in this instance, but this is configurable so check your php.ini file!) we extract the second part of that string as the PHP session. If all else fails we return an empty string which will be compatible with our next function, “authorizePHPSession”.

“authorizePHPSession” takes two parameters, the PHP session id, and a callback function that is to be executed. The callback must be executed as per the documentation here. This function call to read the contents of the file must be asynchronous. Synchronous calls are dangerous in a non blocking i/o situation. I will quote Node.js documentation:

The synchronous versions will block the entire process until they complete–halting all connections.

Trust me I tried the synchronous calls, I watched the connection pool halt and just stack up and it was just one mess. Simply enough if the PHP session id exists in this file then it is authorized (how did the PHP session get into the file, well that is the next part…). Finally pulling it all together I call:

io.configure(function() {
    io.set('transports', ['xhr-polling','htmlfile','jsonp-polling']);
    io.set('authorization', function (data, cb) {
        authorizePHPSession(getPHPSessionId(data.headers.cookie), cb);
    });
});

Now we get into the Zend Framework portion of our example. I am going to assume that once you have authorized the user you write some sort of information into the session. This is our chance to insert the PHP session id to our session.

        $result = $authDbTable->authenticate();
 
        if($result->isValid())
        {
            // lets store the user in the session
            $user = $authDbTable->getResultRowObject(array('id', 'role'), null);
            $usersTable->update(array('lastLogin'=>date('Y-m-d H:i:s')), array('id = ?'=>$user->id));
 
	    if($form->remember_me->checked) {
		Zend_Session::rememberMe();
	    } else {
		Zend_Session::forgetMe();
	    }
 
            // insert our session information.
            $user->nodeAuthorization = Zend_Session::getId();
 
            $auth = Zend_Auth::getInstance();
            $auth->getStorage()->write($user);
        }

Lets discuss the semantics of this operation. PHP is invoked by the browser request. A cookie is written to your browser with your PHP session id. Which is the only unique identifier which will allow you to access serialized data stored in a file on our server. Socket.io is invoked once the page is loaded into your browser. At this point the information contained in your cookies is passed as handshake data to our event server. The event server does the authorization previously mentioned. If the session string exists (which will only happen once you are authenticated) you are granted access, else you are not.

PHP/Node.js/Socket.io is just simply amazing!

BIG BIG BIG EDIT
If the PHP garbage collector has not picked up the sessions yet as it has a random chance of running per page load you can check the stats of the file yourself. However the one CAVEAT is that if you change the length of time for which your sessions are valid you have to do it in two places. application.ini and or Zend_Config for PHP and in the Node.js application file variable. Take a look at this fixed version:

/**
 * This function will look in the PHP Session directory and look for the session
 * file.  If the file exists it will load that file as a string and then parse
 * that string for the PHP Session which will only be stored once the PHP authorization
 * method saves it.  It also takes into consideration sessions that may not have been
 * gc'ed by PHP yet.
 */
var sessionExpiration = 86400;
function authorizePHPSession(data, cb) {
    var phpSessionId = getPHPSessionId(data.headers.cookie);
    fs.stat('/var/lib/php5/sess_'+phpSessionId, function(err, stats) {
        if(err) {
            cb(null, false);
        } else if(Date.now() - (Date.parse(stats.mtime)) > sessionExpiration) {
            cb(null, false);
        } else {
            try {
                fs.readFile('/var/lib/php5/sess_'+phpSessionId, 'utf8', function(err, fileContents) {
                    if(err) {
                        throw err;
                    } else if(fileContents.search(phpSessionId.toString()) > -1) {
                        data.phpSessionId = phpSessionId.toString();
                        cb(null, true);
                    } else {
                        cb(null, false);
                    }
                });
            } catch(e) {
                cb(null, false);
            }            
        }
    });
}

This was brought to my attention by Trii chilling out in #phpc on irc.freenode.org. You can visit him here at g+