/**
* Default constructor for the node object. Do not call this class directly.
* Create a separate class for each content type and use its constructor.
*
* @param int $nid
* Nid if an existing node is to be loaded.
*/
public function __construct($nid = NULL)
{
$class = new \ReflectionClass(get_called_class());
$type = Utils::makeSnakeCase($class->getShortName());
if (!is_null($nid) && is_numeric($nid)) {
$node = node_load($nid);
if (!$node) {
$this->setErrors("Node with nid {$nid} does not exist.");
$this->setInitialized(FALSE);
return;
}
if ($node->type != $type) {
$this->setErrors("Node's type doesn't match the class.");
$this->setInitialized(FALSE);
return;
}
parent::__construct($node);
} else {
global $user;
$node = (object) array('title' => NULL, 'type' => $type, 'language' => LANGUAGE_NONE, 'is_new' => TRUE, 'name' => $user->name);
node_object_prepare($node);
parent::__construct($node);
}
$this->setInitialized(TRUE);
}
/**
* Default constructor for the Commerce Product object. Do not call this
* class directly. Create a separate class for each product type and use its
* constructor.
*
* @param int $product_id
* Product id if an existing product is to be loaded.
*/
public function __construct($product_id = NULL)
{
$class = new \ReflectionClass(get_called_class());
$type = Utils::makeSnakeCase($class->getShortName());
if (!is_null($product_id)) {
$product = NULL;
if (is_numeric($product_id)) {
$product = commerce_product_load($product_id);
}
if ($product && $product->type == $type) {
parent::__construct($product);
return;
}
// SKU might have been passed instead.
$product = commerce_product_load_by_sku($product_id);
if ($product && $product->type == $type) {
parent::__construct($product);
return;
}
if (!$product) {
$this->setErrors("Product with id or sku {$product_id} and type {$type} does not exist.");
$this->setInitialized(FALSE);
return;
}
} else {
$product = commerce_product_new($type);
parent::__construct($product);
}
}
/**
* Default constructor for the user object.
*
* @param int $uid
* User id.
*/
public function __construct($uid = NULL)
{
if (!is_null($uid) && is_numeric($uid) && ($account = user_load($uid))) {
parent::__construct($account);
}
$this->setInitialized(TRUE);
}
/**
* Default constructor for the user object.
*
* @param int $uid
* User id.
*/
public function __construct($uid = NULL)
{
if (!is_null($uid) && is_numeric($uid) && ($account = user_load($uid))) {
parent::__construct($account);
} else {
parent::__construct(NULL);
}
}
/**
* Default constructor for the comment object.
*
* @param int|null $cid
* Cid if an existing comment is to be loaded and null if a new comment is
* to be loaded.
*/
public function __construct($cid = NULL)
{
$args = func_get_args();
array_shift($args);
$nid = array_shift($args);
$pid = array_shift($args);
if (is_null($cid)) {
if (!isset($nid) || !is_numeric($nid)) {
$this->setErrors('Provide nid for a comment add form.');
$this->setInitialized(FALSE);
return;
}
$node = node_load($nid);
$comment = (object) array('nid' => $nid);
} else {
$comment = comment_load($cid);
$comment_nid = $comment->nid;
if (!is_null($nid) && $comment_nid != $nid) {
$this->setErrors('Id of the node associated with the comment and provided node id do not match.');
$this->setInitialized(FALSE);
return;
}
$node = node_load($comment_nid);
}
if (!$node) {
$this->setErrors("Node {$nid} doesn't exist.");
$this->setInitialized(FALSE);
return;
}
if (!is_null($pid)) {
$parent_comment = comment_load($pid);
if (!$parent_comment) {
$this->setInitialized(FALSE);
$this->setErrors("Comment {$pid} does not exist.");
return;
}
if ($parent_comment->nid != $node->nid) {
$this->setInitialized(FALSE);
$this->setErrors("Node id associated with the parent comment and the one that is provided do not match.");
return;
}
$comment->pid = $pid;
}
$classname = get_called_class();
$class = new \ReflectionClass($classname);
$class_shortname = $class->getShortName();
$type = Utils::makeSnakeCase(substr($class_shortname, 0, -7));
if ($node->type != $type) {
$this->setErrors("Classes of comment and the node do not match. Class of comment is {$type} while that of node is " . $node->type . ".");
$this->setInitialized(TRUE);
return;
}
parent::__construct($comment);
}
/**
* Default constructor for the term object.
*
* @param int $tid
* TaxonomyTerm id if an existing term is to be loaded.
*/
public function __construct($tid = NULL)
{
$class = new \ReflectionClass(get_called_class());
$vocabulary_name = Utils::makeSnakeCase($class->getShortName());
if (!is_null($tid) && is_numeric($tid)) {
$term = taxonomy_term_load($tid);
if ($term->vocabulary_machine_name == $vocabulary_name) {
parent::__construct($term);
}
} else {
$term = (object) array('name' => '', 'description' => '', 'format' => NULL, 'vocabulary_machine_name' => $vocabulary_name, 'tid' => NULL, 'weight' => 0);
parent::__construct($term);
}
$this->setInitialized(TRUE);
}
/**
* Default constructor for the Commerce Order object.
*
* @param int $order_id
* Order id if an existing order is to be loaded.
*/
public function __construct($order_id = NULL)
{
if (!is_null($order_id) && is_numeric($order_id)) {
$order = commerce_order_load($order_id);
if (!$order) {
$this->setErrors("Order with id {$order_id} does not exist.");
$this->setInitialized(FALSE);
return;
}
} else {
global $user;
$order = commerce_order_new($user->uid);
}
parent::__construct($order);
}
/**
* Default constructor for the node object. Do not call this class directly.
* Create a separate class for each content type and use its constructor.
*
* @param int $nid
* Nid if an existing node is to be loaded.
*/
public function __construct($nid = NULL)
{
$class = new \ReflectionClass(get_called_class());
$type = Utils::makeSnakeCase($class->getShortName());
if (!is_null($nid) && is_numeric($nid)) {
$node = node_load($nid);
if ($node->type == $type) {
parent::__construct($node);
}
} else {
global $user;
$node = (object) array('title' => NULL, 'type' => $type, 'language' => LANGUAGE_NONE, 'is_new' => TRUE, 'name' => $user->name);
node_object_prepare($node);
parent::__construct($node);
}
$this->setInitialized(TRUE);
}
/**
* Default constructor for the Commerce Customer Profile.
*
* @param int $order_id
* Order id if an existing order is to be loaded.
*/
public function __construct($profile_id = NULL)
{
if (!is_null($profile_id) && is_numeric($profile_id)) {
$profile = commerce_customer_profile_load($profile_id);
if (!$profile) {
$this->setErrors("Profile with id {$profile} does not exist.");
$this->setInitialized(FALSE);
return;
}
} else {
global $user;
$class = new \ReflectionClass(get_called_class());
$type = Utils::makeSnakeCase($class->getShortName());
$profile = commerce_customer_profile_new($type, $user->uid);
}
parent::__construct($profile);
}
/**
* Default constructor for the Commerce Recurring object.
*
* @param int $recurring_id
* Recurring id if an existing recurring entity is to be loaded.
*/
public function __construct($recurring_id = NULL)
{
$class = new \ReflectionClass(get_called_class());
$type = Utils::makeSnakeCase($class->getShortName());
if (!is_null($recurring_id)) {
$rec_entity = NULL;
if (is_numeric($recurring_id)) {
$rec_entity = commerce_recurring_load($recurring_id);
}
if (!empty($rec_entity)) {
parent::__construct($rec_entity);
return;
}
} else {
$rec_entity = commerce_recurring_new(array('type' => $type));
parent::__construct($rec_entity);
}
}
/**
* Default constructor for the Commerce License object.
*
* @param int $license_id
* License id if an existing license entity is to be loaded.
*/
public function __construct($license_id = NULL)
{
$args = func_get_args();
array_shift($args);
$order_id = array_shift($args);
if (is_null($order_id)) {
$order_id = 0;
}
$order = commerce_order_load($order_id);
if (!is_null($order_id)) {
$license = commerce_license_get_order_licenses($order_id);
if (!$license) {
$this->setErrors("License for order id {$order_id} does not exist.");
$this->setInitialized(FALSE);
return;
}
}
parent::__construct($license);
}
/**
* Default constructor for the Commerce Line Item object. Do not call this
* class directly. Create a separate class for each line item type and use
* its constructor.
*
* You can also pass a second argument, and it will be interpreted as
* order_id. It is used for creating a new line item.
*
* @param int $line_item_id
* Product id if an existing product is to be loaded.
*/
public function __construct($line_item_id = NULL)
{
$args = func_get_args();
array_shift($args);
$order_id = array_shift($args);
if (is_null($order_id)) {
$order_id = 0;
}
if (!is_null($line_item_id) && is_numeric($line_item_id)) {
$line_item = commerce_line_item_load($line_item_id);
if (!$line_item) {
$this->setErrors("Line item with id {$line_item_id} does not exist.");
$this->setInitialized(FALSE);
return;
}
} else {
$class = new \ReflectionClass(get_called_class());
$type = Utils::makeSnakeCase($class->getShortName());
$line_item = commerce_line_item_new($type, $order_id);
}
parent::__construct($line_item);
}
/**
* Default constructor for the Commerce Coupon object. Do not call this
* class directly.
*
* @param int $coupon_id
* Coupon id if an existing coupon is to be loaded.
* @param int $code
* Coupon code if an existing coupon is to be loaded.
*/
public function __construct($coupon_id = NULL, $code = NULL)
{
if (!is_null($coupon_id)) {
$coupon = commerce_coupon_load($coupon_id);
if (!$coupon) {
$this->setErrors("Coupon with id {$coupon} does not exist.");
$this->setInitialized(FALSE);
return;
}
} else {
if (!is_null($code)) {
$coupon = commerce_coupon_load_by_code($code);
if (!$coupon) {
$this->setErrors("Coupon with code {$code} does not exist.");
$this->setInitialized(FALSE);
return;
}
} else {
$coupon = commerce_coupon_create('discount_coupon');
}
}
parent::__construct($coupon);
}
