/**
* Constructor
*
* @param RedBean_ToolBox $tools toolbox
*/
public function __construct(RedBean_ToolBox $tools)
{
$this->oodb = $tools->getRedBean();
$this->adapter = $tools->getDatabaseAdapter();
$this->writer = $tools->getWriter();
$this->toolbox = $tools;
}
/**
* Scans the toolbox to determine whether the database adapter
* is compatible with the current class, plugin or module.
* @throws RedBean_Exception_UnsupportedDatabase $exception
* @param RedBean_ToolBox $toolbox
* @return bool $compatible
*/
public function scanToolBox(RedBean_ToolBox $toolbox)
{
//obtain the database system
$brand = strtolower(trim($toolbox->getDatabaseAdapter()->getDatabase()->getDatabaseType()));
//obtain version number
$version = $toolbox->getDatabaseAdapter()->getDatabase()->getDatabaseVersion();
if (!is_numeric($version)) {
$version = 999;
//No version number? Ignore!
}
//compare database
if (isset($this->supportedSystems[$brand]) && (double) $this->supportedSystems[$brand] <= (double) $version) {
return true;
} else {
if (!self::$ignoreVersion) {
$this->messageUnsupported = str_replace("##YOU##", $brand . " v" . $version, $this->messageUnsupported);
$list = array();
foreach ($this->supportedSystems as $supported => $version) {
$list[] = " " . $supported . " v" . $version . "+";
}
$this->messageUnsupported = str_replace("##DBS##", implode(",", $list), $this->messageUnsupported);
throw new RedBean_Exception_UnsupportedDatabase($this->messageUnsupported);
} else {
return false;
}
}
}
/**
*
* Constructor, requires a type name
* @param string $typeName
*/
public function __construct($typeName)
{
$this->tools = RedBean_Setup::getToolBox();
$this->redbean = $this->tools->getRedBean();
$this->bean = $this->redbean->dispense($typeName);
$this->associationManager = new RedBean_AssociationManager($this->tools);
$this->treeManager = new RedBean_TreeManager($this->tools);
}
/**
* Constructor, requires a writer
* @param RedBean_QueryWriter $writer
*/
public function __construct(RedBean_ToolBox $toolbox)
{
$this->writer = $toolbox->getWriter();
$this->adapter = $toolbox->getDatabaseAdapter();
$this->redbean = $toolbox->getRedBean();
if ($this->redbean->isFrozen()) {
$this->adapter->exec("\n\t\t\t\t\t\tCREATE TABLE IF NOT EXISTS `__log` (\n\t\t\t\t\t\t`id` INT( 11 ) NOT NULL AUTO_INCREMENT PRIMARY KEY ,\n\t\t\t\t\t\t`tbl` VARCHAR( 255 ) NOT NULL ,\n\t\t\t\t\t\t`action` TINYINT( 2 ) NOT NULL ,\n\t\t\t\t\t\t`itemid` INT( 11 ) NOT NULL\n\t\t\t\t\t\t) ENGINE = MYISAM ;\n\t\t\t\t");
//Must be MyISAM! else you run in trouble if you use transactions!
}
$maxid = $this->adapter->getCell("SELECT MAX(id) FROM __log");
$this->adapter->exec("DELETE FROM __log WHERE id < {$maxid} - 200 ");
}
/**
* Returns the bean identified by the RESTful path.
* For instance:
*
* $user
* /site/1/page/3
*
* returns page with ID 3 in ownPage of site 1 in ownSite of
* $user bean.
*
* Works with shared lists as well:
*
* $user
* /site/1/page/3/shared-ad/4
*
* Note that this method will open all intermediate beans so you can
* attach access control rules to each bean in the path.
*
* @param RedBean_OODBBean $bean
* @param array $steps (an array representation of a REST path)
*
* @return RedBean_OODBBean
*
* @throws RedBean_Exception_Security
*/
public function findByPath($bean, $steps)
{
$numberOfSteps = count($steps);
if (!$numberOfSteps) {
return $bean;
}
if ($numberOfSteps % 2) {
throw new RedBean_Exception_Security('Invalid path: needs 1 more element.');
}
for ($i = 0; $i < $numberOfSteps; $i += 2) {
$steps[$i] = trim($steps[$i]);
if ($steps[$i] === '') {
throw new RedBean_Exception_Security('Cannot access list.');
}
if (strpos($steps[$i], 'shared-') === FALSE) {
$listName = 'own' . ucfirst($steps[$i]);
$listType = $this->toolbox->getWriter()->esc($steps[$i]);
} else {
$listName = 'shared' . ucfirst(substr($steps[$i], 7));
$listType = $this->toolbox->getWriter()->esc(substr($steps[$i], 7));
}
$list = $bean->withCondition(" {$listType}.id = ? ", array($steps[$i + 1]))->{$listName};
if (!isset($list[$steps[$i + 1]])) {
throw new RedBean_Exception_Security('Cannot access bean.');
}
$bean = $list[$steps[$i + 1]];
}
return $bean;
}
/**
* Properly untether new clone by re-configuring with a fresh toolbox
*
* @return void
*/
public function __clone()
{
$class = get_class($this->toolbox->getWriter());
$writer = new $class($this->toolbox->getDatabaseAdapter());
$redbean = new RedBean_OODB($writer);
$toolbox = new RedBean_ToolBox($redbean, $this->toolbox->getDatabaseAdapter(), $writer);
$this->configureWithToolbox($toolbox);
}
/**
*
* Constructor, requires a type name
* @param string $typeName
*/
public function __construct($typeName = false)
{
/**
* If no typeName has been specified,
* figure out the type of this model yourself.
* In this case the following rule applies:
* - the name of the model is the LAST part of the
* namespace.
* - Within that string, the name of the model is the LAST
* part of the poorman's name space.
*
* So the model name for class: /me/him/her is: her
* So the model name for class: /me/him/her_lover is: lover
*/
if (!$typeName) {
//Fetch the bean type using the class
$beanTypeName = get_class($this);
//Get last part of namespace
$a = explode("\\", $beanTypeName);
$lastInNameSpace = array_pop($a);
//Get last part of poorman's namespace (underscores)
$a = explode("_", $lastInNameSpace);
$lastInPoormanNameSpace = array_pop($a);
$beanTypeName = $lastInPoormanNameSpace;
}
/*
* Now do a little check to see whether this name
* can be used. - Just a quick check, we will re-check later on
*/
if ($beanTypeName && strlen($beanTypeName) > 0) {
//Fetch us a toolbox.
$this->tools = RedBean_Setup::getToolBox();
$this->redbean = $this->tools->getRedBean();
//Here the bean type is checked properly.
$this->bean = $this->redbean->dispense($beanTypeName);
//Create some handy modules so you dont have to do the wiring yourself.
$this->associationManager = new RedBean_AssociationManager($this->tools);
$this->treeManager = new RedBean_TreeManager($this->tools);
} else {
throw new Exception("Invalid Domain Object TypeName");
}
}
/**
* Configures the facade, want to have a new Writer? A new Object Database or a new
* Adapter and you want it on-the-fly? Use this method to hot-swap your facade with a new
* toolbox.
*
* @param RedBean_ToolBox $tb toolbox
*
* @return RedBean_ToolBox
*/
public function configureFacadeWithToolbox(RedBean_ToolBox $tb)
{
$oldTools = $this->toolbox;
$this->toolbox = $tb;
$this->writer = $this->toolbox->getWriter();
$this->adapter = $this->toolbox->getDatabaseAdapter();
$this->redbean = $this->toolbox->getRedBean();
$this->finder = new RedBean_Finder($this->toolbox);
$this->associationManager = new RedBean_AssociationManager($this->toolbox);
$this->redbean->setAssociationManager($this->associationManager);
$this->labelMaker = new RedBean_LabelMaker($this->toolbox);
$this->extAssocManager = new RedBean_AssociationManager_ExtAssociationManager($this->toolbox);
$helper = new RedBean_ModelHelper();
$helper->attachEventListeners($this->redbean);
$this->associationManager->addEventListener('delete', $helper);
$this->duplicationManager = new RedBean_DuplicationManager($this->toolbox);
$this->tagManager = new RedBean_TagManager($this->toolbox);
$this->f = new RedBean_SQLHelper($this->adapter);
return $oldTools;
}
/**
* Configures the facade, want to have a new Writer? A new Object Database or a new
* Adapter and you want it on-the-fly? Use this method to hot-swap your facade with a new
* toolbox.
*
* @param RedBean_ToolBox $tb toolbox
*
* @return RedBean_ToolBox
*/
public static function configureFacadeWithToolbox(RedBean_ToolBox $tb)
{
$oldTools = self::$toolbox;
self::$toolbox = $tb;
self::$writer = self::$toolbox->getWriter();
self::$adapter = self::$toolbox->getDatabaseAdapter();
self::$redbean = self::$toolbox->getRedBean();
self::$finder = new RedBean_Finder(self::$toolbox);
self::$associationManager = new RedBean_AssociationManager(self::$toolbox);
self::$redbean->setAssociationManager(self::$associationManager);
self::$labelMaker = new RedBean_LabelMaker(self::$toolbox);
self::$extAssocManager = new RedBean_AssociationManager_ExtAssociationManager(self::$toolbox);
$helper = new RedBean_ModelHelper();
$helper->attachEventListeners(self::$redbean);
self::$associationManager->addEventListener('delete', $helper);
self::$duplicationManager = new RedBean_DuplicationManager(self::$toolbox);
self::$tagManager = new RedBean_TagManager(self::$toolbox);
self::$f = new RedBean_SQLHelper(self::$adapter);
return $oldTools;
}
/**
* Configures the facade, want to have a new Writer? A new Object Database or a new
* Adapter and you want it on-the-fly? Use this method to hot-swap your facade with a new
* toolbox.
*
* @static
* @param RedBean_ToolBox $tb toolbox
*
* @return RedBean_ToolBox $tb old, rusty, previously used toolbox
*/
public static function configureFacadeWithToolbox(RedBean_ToolBox $tb)
{
$oldTools = self::$toolbox;
self::$toolbox = $tb;
self::$writer = self::$toolbox->getWriter();
self::$adapter = self::$toolbox->getDatabaseAdapter();
self::$redbean = self::$toolbox->getRedBean();
self::$associationManager = new RedBean_AssociationManager(self::$toolbox);
self::$redbean->setAssociationManager(self::$associationManager);
self::$extAssocManager = new RedBean_ExtAssociationManager(self::$toolbox);
$helper = new RedBean_ModelHelper();
self::$redbean->addEventListener("update", $helper);
self::$redbean->addEventListener("open", $helper);
self::$redbean->addEventListener("delete", $helper);
self::$associationManager->addEventListener("delete", $helper);
self::$redbean->addEventListener("after_delete", $helper);
self::$redbean->addEventListener("after_update", $helper);
self::$redbean->addEventListener("dispense", $helper);
return $oldTools;
}
/**
* Constructor.
* This Object requires a toolbox.
*
* @param RedBean_ToolBox $toolbox toolbox for DB operations.
*/
public function __construct(RedBean_ToolBox $toolbox)
{
$this->writer = $toolbox->getWriter();
$this->adapter = $toolbox->getDatabaseAdapter();
}
public static function load($post, RedBean_ToolBox $toolbox)
{
$writer = $toolbox->getWriter();
if (isset($post["associations"])) {
$associations = $post["associations"];
unset($post["associations"]);
}
$can = $pairs = $sorted = array();
foreach ($post as $key => $rawBean) {
if (is_array($rawBean) && isset($rawBean["type"])) {
$type = $rawBean["type"];
unset($rawBean["type"]);
$idfield = $writer->getIDField($type);
if (isset($rawBean[$idfield])) {
$id = $rawBean[$idfield];
if ($id == 0 && count($rawBean) === 1) {
continue;
}
unset($rawBean[$idfield]);
$bean = R::load($type, $id);
} else {
$bean = R::dispense($type);
}
foreach ($rawBean as $field => $value) {
if (!empty($value)) {
$bean->{$field} = $value;
}
}
$can[$key] = $bean;
if (!isset($sorted[$type])) {
$sorted[$type] = array();
}
$sorted[$type][] = $bean;
}
}
if (isset($associations) && is_array($associations)) {
foreach ($associations as $assoc) {
foreach ($assoc as $info) {
if ($info == "0" || $info == "") {
continue;
}
$keys = explode("-", $info);
if (isset($can[$keys[0]])) {
$bean1 = $can[$keys[0]];
} else {
$loader = explode(":", $keys[0]);
$bean1 = R::load($loader[0], $loader[1]);
}
$bean2 = $can[$keys[1]];
$pairs[] = array($bean1, $bean2);
}
}
}
return array("can" => $can, "pairs" => $pairs, "sorted" => $sorted);
}
/**
* This method will inspect the array provided and load/dispense the
* desired beans. To dispense a new bean, the array must contain:
*
* array( "newuser"=> array("type"=>"user","name"=>"John") )
*
* - Creates a new bean of type user, property name is set to "John"
*
* To load a bean (for association):
*
* array( "theaddress"=> array("type"=>"address","id"=>2) )
*
* - Loads a bean of type address with ID 2
*
* Now to associate this bean in your form:
*
* array("associations"=>array( "0" => array( "newuser-theaddress" ) ))
*
* - Associates the beans under keys newuser and theaddress.
*
* To modify an existing bean:
*
* array("existinguser"=>array("type"=>"user","id"=>2,"name"=>"Peter"))
*
* - Changes name of bean of type user with ID 2 to 'Peter'
*
* This function returns:
*
* array(
* "can" => an array with beans, either loaded or dispensed and populated
* "pairs" => an array with pairs of beans to be associated
* "sorted" => sorted by type
* );
*
* Note that this function actually does not store or associate anything at all,
* it just prepares two arrays.
*
* @static
* @param $post the POST array containing the form data
* @return array hash table containing 'can' and 'pairs'
*
*/
public static function load($post, RedBean_ToolBox $toolbox)
{
$writer = $toolbox->getWriter();
//fetch associations first and remove them from the array.
if (isset($post["associations"])) {
$associations = $post["associations"];
unset($post["associations"]);
}
//We store beans here
$can = $pairs = $sorted = array();
foreach ($post as $key => $rawBean) {
if (is_array($rawBean) && isset($rawBean["type"])) {
//get type and remove it from array
$type = $rawBean["type"];
unset($rawBean["type"]);
//does it have an ID?
$idfield = $writer->getIDField($type);
if (isset($rawBean[$idfield])) {
//yupz, get the id and remove it from array
$id = $rawBean[$idfield];
//ID == 0, and no more fields then this is an NULL option for a relation, skip.
if ($id == 0 && count($rawBean) === 1) {
continue;
}
unset($rawBean[$idfield]);
//now we have the id, load the bean and store it in the can
$bean = RedBean_Facade::load($type, $id);
} else {
//no id? then get a new bean...
$bean = RedBean_Facade::dispense($type);
}
//do we need to modify this bean?
foreach ($rawBean as $field => $value) {
if (!empty($value)) {
$bean->{$field} = $value;
} elseif (!self::$dontSetEmptyValues) {
$bean->{$field} = $value;
}
}
$can[$key] = $bean;
if (!isset($sorted[$type])) {
$sorted[$type] = array();
}
$sorted[$type][] = $bean;
}
}
if (isset($associations) && is_array($associations)) {
foreach ($associations as $assoc) {
foreach ($assoc as $info) {
if ($info == "0" || $info == "") {
continue;
}
$keys = explode("-", $info);
//first check if we can find the key in the can, --only key 1 is able to load
if (isset($can[$keys[0]])) {
$bean1 = $can[$keys[0]];
} else {
$loader = explode(":", $keys[0]);
$bean1 = RedBean_Facade::load($loader[0], $loader[1]);
}
$bean2 = $can[$keys[1]];
$pairs[] = array($bean1, $bean2);
}
}
}
return array("can" => $can, "pairs" => $pairs, "sorted" => $sorted);
}
/**
* Constructor.
* @param RedBean_OODB $oodb
* @param RedBean_ToolBox $toolBox
*/
public function __construct(RedBean_OODB $oodb, RedBean_ToolBox $toolBox)
{
$this->oodb = $oodb;
$this->writer = $toolBox->getWriter();
}
/**
* Returns the ID of the Model.
*/
public function getID()
{
$idField = $this->tools->getWriter()->getIDField($this->bean->getMeta("type"));
return $this->bean->{$idField};
}
/**
* Constructor.
* Creates a new instance of the Resty BeanCan Server.
* If no toolbox is provided the Resty BeanCan Server object will
* try to obtain the toolbox currently used by the RedBeanPHP facade.
* If you use only the R-methods and not the advanced objects this should be fine.
*
* @param RedBean_ToolBox $toolbox (optional)
*/
public function __construct($toolbox = NULL)
{
if ($toolbox instanceof RedBean_ToolBox) {
$this->toolbox = $toolbox;
$this->oodb = $toolbox->getRedBean();
} else {
$this->toolbox = RedBean_Facade::getToolBox();
$this->oodb = RedBean_Facade::getRedBean();
}
}
/**
* Kickstarts redbean for you.
* @param string $dsn
* @param string $username
* @param string $password
*/
public static function setup($dsn = "sqlite:/tmp/red.db", $username = NULL, $password = NULL)
{
RedBean_Setup::kickstart($dsn, $username, $password);
self::$toolbox = RedBean_Setup::getToolBox();
self::$writer = self::$toolbox->getWriter();
self::$adapter = self::$toolbox->getDatabaseAdapter();
self::$redbean = self::$toolbox->getRedBean();
self::$associationManager = new RedBean_AssociationManager(self::$toolbox);
self::$treeManager = new RedBean_TreeManager(self::$toolbox);
self::$linkManager = new RedBean_LinkManager(self::$toolbox);
self::$extAssocManager = new RedBean_ExtAssociationManager(self::$toolbox);
$helper = new RedBean_ModelHelper();
self::$redbean->addEventListener("update", $helper);
self::$redbean->addEventListener("open", $helper);
self::$redbean->addEventListener("delete", $helper);
}
