/**
* 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 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 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);
}
public static function getValues(Entity $entityObject, $field_name, $post_process = FALSE)
{
$field = $entityObject->getFieldItems($field_name);
return $field;
}
/**
* Returns information about field instance.
*
* @param Entity $entityObject
* Entity for which the field instance is to be returned.
* @param string $field_name
* Field name.
*
* @return array|null
* An array of field instance information if the instance exists. NULL if
* the field instance does not exist.
*/
public static function getFieldInstance(Entity $entityObject, $field_name)
{
list(, , $bundle) = entity_extract_ids($entityObject->getEntityType(), $entityObject->getEntity());
$instance = field_info_instance($entityObject->getEntityType(), $field_name, $bundle);
return $instance;
}
public static function getFileGenericValues(Entity $entityObject, $field_name, $post_process = FALSE)
{
$field = $entityObject->getFieldItems($field_name);
if (!$post_process) {
return $field;
}
$output = array();
foreach ($field as $fid => $file) {
$output[] = $fid;
}
return Utils::normalize($output);
}
/**
* Magic method.
*
* @param string $name
* Function name that is called.
* @param array $arguments
* An array of arguments.
*
* @return mixed
* Depends on which function is invoked.
*/
public function __call($name, $arguments)
{
if ($name == 'logout') {
static::logoutFunction();
} else {
return parent::__call($name, $arguments);
}
}
/**
* Reload the order from the database. This is necessary so that
* commerce_cart_commerce_order_load() function can get called, which in turn
* invokes the rule "Override price for recurring" provided by the recurring
* framework.
*/
public function reload()
{
// Unsetting $refreshed in commerce_cart_commerce_order_load() is needed so
// that commerce_cart_order_refresh() can be called.
drupal_static_reset('commerce_cart_commerce_order_load');
// Temporarily set the value of commerce_cart_refresh_frequency to 0 so that
// the function commerce_cart_order_can_refresh() which is called in
// commerce_cart_commerce_order_load() returns TRUE and
// commerce_cart_order_refresh() can actually get called.
$commerce_cart_refresh_frequency = variable_get('commerce_cart_refresh_frequency', 0);
global $conf;
$conf['commerce_cart_refresh_frequency'] = 0;
// Load the order from the database which should call the "Override price
// for recurring" rule provided by recurring framework.
parent::reload();
// Set value of commerce_cart_refresh_frequency variable back to what it was
// earlier.
$conf['commerce_cart_refresh_frequency'] = $commerce_cart_refresh_frequency;
}
