File Source for PersonObject.inc

<?php
require_once $config->get('sysRoot').'alpha/model/AlphaDAO.inc';
require_once $config->get('sysRoot').'alpha/model/RightsObject.inc';
require_once $config->get('sysRoot').'alpha/model/ArticleCommentObject.inc';
/**
*
* The main person/user class for the site
*
* @package alpha::model
* @since 1.0
* @author John Collins <dev@alphaframework.org>
* @version $Id: PersonObject.inc 1453 2011-12-04 15:12:54Z johnc $
* @license http://www.opensource.org/licenses/bsd-license.php The BSD License
* @copyright Copyright (c) 2011, John Collins (founder of Alpha Framework).
* All rights reserved.
*
* <pre>
* Redistribution and use in source and binary forms, with or
* without modification, are permitted provided that the
* following conditions are met:
*
* * Redistributions of source code must retain the above
* copyright notice, this list of conditions and the
* following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the
* following disclaimer in the documentation and/or other
* materials provided with the distribution.
* * Neither the name of the Alpha Framework nor the names
* of its contributors may be used to endorse or promote
* products derived from this software without specific
* prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* </pre>
*
*/
class PersonObject extends AlphaDAO {
/**
* The forum display name of the person
*
* @var String
* @since 1.0
*/
protected $displayName;
/**
* The email address for the person
*
* @var String
* @since 1.0
*/
protected $email;
/**
* The password for the person
*
* @var String
* @since 1.0
*/
protected $password;
/**
* A Relation containing all of the rights groups that this person belongs to
*
* @var Relation
* @since 1.0
*/
protected $rights;
/**
* An array of data display labels for the class properties
*
* @var array
* @since 1.0
*/
protected $dataLabels = array("OID"=>"Member ID#",
"displayName"=>"Display Name",
"email"=>"E-mail Address",
"password"=>"Password",
"state"=>"Account state",
"URL"=>"Your site address",
"rights"=>"Rights Group Membership");
/**
* The name of the database table for the class
*
* @var string
* @since 1.0
*/
const TABLE_NAME = 'Person';
/**
* The state of the person (account status)
*
* @var Enum
* @since 1.0
*/
protected $state;
/**
* The website URL of the person
*
* @var String
* @since 1.0
*/
protected $URL;
/**
* Trace logger
*
* @var Logger
* @since 1.0
*/
private static $logger = null;
/**
* Constructor for the class that populates all of the complex types with default values
*
* @since 1.0
*/
public function __construct() {
self::$logger = new Logger('PersonObject');
self::$logger->debug('>>__construct()');
// ensure to call the parent constructor
parent::__construct();
$this->displayName = new String();
$this->displayName->setRule(AlphaValidator::REQUIRED_USERNAME);
$this->displayName->setSize(70);
$this->displayName->setHelper('Please provide a name for display on the website (only letters, numbers, and .-_ characters are allowed!).');
$this->email = new String();
$this->email->setRule(AlphaValidator::REQUIRED_EMAIL);
$this->email->setSize(70);
$this->email->setHelper('Please provide a valid e-mail address as your username.');
$this->password = new String();
$this->password->setSize(70);
$this->password->setHelper('Please provide a password for logging in.');
$this->password->isPassword(true);
$this->state = new Enum(array(
'Active',
'Disabled'));
$this->state->setValue('Active');
$this->URL = new String();
$this->URL->setRule(AlphaValidator::OPTIONAL_HTTP_URL);
$this->URL->setHelper('URLs must be in the format http://some_domain/ or left blank!');
// add unique keys to displayName and email (which is effectively the username in Alpha)
$this->markUnique('displayName');
$this->markUnique('email');
$this->rights = new Relation();
$this->markTransient('rights');
$this->setupRels();
self::$logger->debug('<<__construct');
}
/**
* Set up the transient attributes for the rights group after it has loaded
*
* @since 1.0
*/
protected function after_load_callback() {
$this->setupRels();
}
/**
* Set up the transient attributes for the site after it has loaded
*
* @since 1.0
*/
protected function after_loadByAttribute_callback() {
$this->setupRels();
}
/**
* Looks up the OID for the Standard rights group, then relates the new person
* to that group if they are not in it already. If that group does not exist it
* will be recreated!
*
* @since 1.0
*/
protected function after_save_callback() {
if($this->getVersionNumber()->getValue() == 1) {
$standardGroup = new RightsObject();
$this->setupRels();
if(!$this->inGroup('Standard')) {
try {
$standardGroup->loadByAttribute('name', 'Standard');
}catch (BONotFoundException $e) {
$standardGroup->set('name', 'Standard');
$standardGroup->save();
}
$lookup = $this->rights->getLookup();
$lookup->setValue(array($this->getID(), $standardGroup->getID()));
$lookup->save();
}
}
}
/**
* Encrypts any fields called 'password' posted for the PersonObject
*
* @since 1.0
*/
protected function before_populateFromPost_callback() {
if(isset($_POST['password']) && preg_match(AlphaValidator::REQUIRED_STRING, $_POST['password']))
$_POST['password'] = crypt($_POST['password']);
}
/**
* Sets up the Relation definitions on this BO
*
* @since 1.0
*/
protected function setupRels() {
// set up MANY-TO-MANY relation person2rights
if(isset($this->rights)) {
$this->rights->setRelatedClass('PersonObject', 'left');
$this->rights->setRelatedClassDisplayField('email', 'left');
$this->rights->setRelatedClass('RightsObject', 'right');
$this->rights->setRelatedClassDisplayField('name', 'right');
$this->rights->setRelationType('MANY-TO-MANY');
$this->rights->setValue($this->getID());
}
}
/**
* Setter for displayName
*
* @param string $displayName
* @since 1.0
*/
public function setDisplayName($displayName) {
$this->displayName->setValue($displayName);
}
/**
* Getter for displayName
*
* @return String
* @since 1.0
*/
public function getDisplayName() {
return $this->displayName;
}
/**
* Checks to see if the person is in the rights group specified
*
* @param string $groupName
* @return bool
* @since 1.0
*/
public function inGroup($groupName) {
if(self::$logger == null)
self::$logger = new Logger('PersonObject');
self::$logger->debug('>>inGroup(groupName=['.$groupName.'])');
$group = new RightsObject();
try {
$group->loadByAttribute('name', $groupName);
}catch (BONotFoundException $e) {
self::$logger->error('Unable to load the group named ['.$groupName.']');
self::$logger->debug('<<inGroup [false]');
return false;
}
$rel = $group->getMembers();
try {
// load all person2rights RelationLookup objects for this person
$lookUps = $rel->getLookup()->loadAllByAttribute('leftID', $this->getID());
foreach($lookUps as $lookUp) {
// the rightID (i.e. RightsObject OID) will be on the right side of the value array
$ids = $lookUp->getValue();
// if we have found a match, return true right away
if($ids[1] == $group->getID()) {
self::$logger->debug('<<inGroup [true]');
return true;
}
}
}catch (BONotFoundException $e) {
self::$logger->debug('<<inGroup [false]');
return false;
}
self::$logger->debug('<<inGroup [false]');
return false;
}
/**
* A generic method for mailing a person
*
* @param string $message
* @param string $subject
* @since 1.0
* @throws MailNotSentException
*/
public function sendMail($message, $subject) {
global $config;
$body = '<html><head></head><body><p>Dear '.$this->getDisplayName().',</p>';
$body .= $message;
$body .= '</body></html>';
$headers = 'MIME-Version: 1.0'."\n";
$headers .= 'Content-type: text/html; charset=iso-8859-1'."\n";
$headers .= "From: ".$config->get('sysReplyTo')."\n";
try {
mail($this->get('email'), $subject, $body, $headers);
}catch (PHPException $e) {
throw new MailNotSentException('Error sending a mail to ['.$this->get('email').']');
}
}
/**
* Generates a random password for the user
*
* @return string
* @since 1.0
*/
public function generatePassword() {
$alphabet = array('a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z');
// the password will be 7 random characters and 2 numbers
$newPassword = '';
for ($i = 0; $i < 7; $i++) {
$newPassword.= $alphabet[rand(0,25)];
}
$newPassword.= rand(0,100);
$newPassword.= rand(0,100);
return $newPassword;
}
/**
* Method for getting a count of the amount of article comments posted by the user
*
* @return integer
* @since 1.0
* @throws AlphaException
*/
public function getCommentCount() {
$temp = new ArticleCommentObject();
$sqlQuery = "SELECT COUNT(OID) AS post_count FROM ".$temp->getTableName()." WHERE created_by='".$this->OID."';";
$result = $this->query($sqlQuery);
if(!isset($result[0])) {
throw new AlphaException('Failed to get the count of the comments posted for the person ['.$this->getDisplayName().'], query is ['.$sqlQuery.']');
return 0;
}
$row = $result[0];
if(isset($row['post_count']))
return $row['post_count'];
else
return 0;
}
}
?>

	alpha--model

[ class tree: alpha--model ] [ index: alpha--model ] [ all elements ]

Source for file PersonObject.inc