OrderProcessQueue - Code Metrics - sunnysideup/silverstripe-ecommerce - Measure and Improve Code Quality continuously with Scrutinizer

OrderProcessQueue B
last analyzed 2019-09-15 09:38 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	479
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	14

Importance

Changes

Metric	Value
dl	0
loc	479
rs	8.8798
c	0
b	0
f	0
wmc	44
lcom	2
cbo	14

22 Methods

Rating	Name	Size	Complexity
A	canCreate()	4	1
A	canView()	19	5
A	canEdit()	4	1
A	canDelete()	4	1
A	i18n_singular_name()	4	1
A	i18n_plural_name()	4	1
A	AddOrderToQueue()	26	5
B	process()	58	10
A	getQueueObject()	6	1
A	removeOrderFromQueue()	7	2
A	OrdersToBeProcessed()	25	2
A	AllOrdersInQueue()	9	1
A	OrdersInQueueThatAreNotReady()	23	2
A	isReadyToGo()	4	1
A	ToBeProcessedAt()	4	1
A	getToBeProcessedAt()	4	1
A	HasBeenInQueueForSince()	4	1
A	getHasBeenInQueueForSince()	4	1
A	getCMSFields()	44	2
A	requireDefaultRecords()	9	2
A	sortPhrase()	7	1
A	sortPhraseForOrderIDs()	4	1

How to fix Complexity

<?php
/**
 * This class provides a bunch of Meta Objects
 * that do not interact with the object at hand, but rather with the datalist as a whole.
 *
 */

class OrderProcessQueue extends DataObject
{
    private static $db = array(

        'DeferTimeInSeconds' => 'Int',
        'InProcess' => 'Boolean',
        'ProcessAttempts' => 'Int'
    );

    private static $has_one = array(

        'Order' => 'Order',
        'OrderStep' => 'OrderStep'
    );

    private static $indexes = array(

        'DeferTimeInSeconds' => true,
        'ProcessAttempts' => true
    );

    private static $casting = array(

        'ToBeProcessedAt' => 'SS_Datetime',
        'HasBeenInQueueSince' => 'SS_Datetime'
    );

    private static $default_sort = [

        'ID' => 'DESC'
    ];

    /**
     * standard SS variable.
     *
     * @var array
     */
    private static $summary_fields = array(

        'Order.Title' => 'Order',
        'Order.Status.Title' => 'Current Step',
        'ProcessAttempts' => 'Attempts',
        'ToBeProcessedAt.Nice' => 'To be processed at',
        'ToBeProcessedAt.Ago' => 'That is ...',
        'HasBeenInQueueForSince.Nice' => 'Added to queue ...',
        'InProcess.Nice' => 'Currently Running'
    );

    /**
     * standard SS variable.
     *
     * @var array
     */
    private static $searchable_fields = array(

        'OrderID' => array(
            'field' => 'NumericField',
            'title' => 'Order Number',
        )
    );


    /**
     * Standard SS method.
     *
     * @param Member $member

     *
     * @return bool
     */
    public function canCreate($member = null)
    {
        return false;
    }

    /**
     * Standard SS method.
     *
     * @param Member $member

     *
     * @return bool

     */
    public function canView($member = null)
    {
        if (! $member) {
            $member = Member::currentUser();
        }
        $extended = $this->extendedCan(__FUNCTION__, $member);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        if ($extended !== null) {
            return $extended;
        }
        if (Permission::checkMember($member, Config::inst()->get('EcommerceRole', 'admin_permission_code'))) {
            return true;
        }
        //is the member is a shop assistant they can always view it
        if (EcommerceRole::current_member_is_shop_assistant($member)) {
            return true;
        }

        return parent::canView($member);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    /**
     * Standard SS method.
     *
     * @param Member $member

     *
     * @return bool
     */
    public function canEdit($member = null)
    {
        return false;
    }

    /**
     * Standard SS method
     * Queues can be deleted if needed.
     *
     * @param Member $member

     *
     * @return bool

     */
    public function canDelete($member = null)
    {
        return parent::canDelete($member);
    }

    /**
     * standard SS variable.
     *
     * @var string
     */
    private static $singular_name = 'Order To Be Processed';

    public function i18n_singular_name()
    {
        return _t('OrderProcessQueue.SINGULAR_NAME', 'Order In Queue');
    }

    /**
     * standard SS variable.
     *
     * @var string
     */
    private static $plural_name = 'Orders to be Processed';

    public function i18n_plural_name()
    {
        return _t('OrderProcessQueue.PLURAL_NAME', 'Orders In Queue');
    }


    /**
     * META METHOD: Add an order to the job list if it does not exist already.
     *
     * @param Order $order
     * @param Int   $deferInSeconds
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     */
    public function AddOrderToQueue($order, $deferTimeInSeconds)
    {
        if (!$order || ! $order->ID) {
            user_error('No real order provided.');
        }
        $filter = array(
            'OrderID' => $order->ID,
            'OrderStepID' => $order->StatusID
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        );
        $existingEntry = DataObject::get_one(
            'OrderProcessQueue',
            $filter,
            $cacheDataObjectGetOne = false
        );
        $filter['DeferTimeInSeconds'] = $deferTimeInSeconds;
        if (! $existingEntry) {
            $existingEntry = OrderProcessQueue::create($filter);
        } else {
            foreach ($filter as $field => $value) {
                $existingEntry->$field = $value;
            }
        }
        $existingEntry->write();

        return $existingEntry;
    }

    /**
     * META METHOD
     * processes the order ...
     * returns TRUE if SUCCESSFUL and a message if unsuccessful ...
     *
     *
     * @param  Order $order optional

     * @return boolean | string

     */
    public function process($order = null)
    {
        //find variables
        if (! $order) {
            $order = $this->Order();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            $myQueueObject = $this;
        } else {
            $myQueueObject = $this->getQueueObject($order);
        }
        //delete if order is gone ...
        if ($order) {
            //if order has moved already ... delete
            if (
                $order->IsCancelled() ||
                $order->IsArchived()
            ) {
                $myQueueObject->delete();
                $message = 'Order is archived already and/or cancelled.';
            } elseif (
                $this->OrderStepID > 0
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                && (int)$order->StatusID !== (int)$myQueueObject->OrderStepID
            ) {
                $message = 'Order has already moved on.';
                $myQueueObject->delete();
            } else {
                if ($myQueueObject) {
                    if ($myQueueObject->isReadyToGo()) {
                        $oldOrderStatusID = $order->StatusID;
                        $myQueueObject->InProcess = true;
                        $myQueueObject->ProcessAttempts = $myQueueObject->ProcessAttempts + 1;
                        $myQueueObject->write();
                        $order->tryToFinaliseOrder(
                            $tryAgain = false,
                            $fromOrderQueue = true
                        );
                        $newOrderStatusID = $order->StatusID;
                        if ($oldOrderStatusID != $newOrderStatusID) {
                            $myQueueObject->delete();
                            return true;
                        } else {
                            $message = 'Attempt to move order was not successful.';
                            $myQueueObject->InProcess = false;
                            $myQueueObject->write();
                        }
                    } else {
                        $message = 'Minimum order queue time has not been passed.';
                    }
                } else {
                    $message = 'Could not find queue object.';
                }
            }
        } else {
            $message = 'Can not find order.';
            $myQueueObject->delete();
        }

        return $message;
    }

    /**
     * META METHOD: returns the queue object if it exists
     *
     * @param  Order $order
     *
     * @return null |   OrderProcessQueue

     */
    public function getQueueObject($order)
    {
        $filter = array('OrderID' => $order->ID);

        return DataObject::get_one('OrderProcessQueue', $filter);
    }

    /**
     * META METHOD: Once you are done, you can remove the item like this ...
     *
     * @param  Order $order
     */
    public function removeOrderFromQueue($order)
    {
        $queueEntries = OrderProcessQueue::get()->filter(array('OrderID' => $order->ID));
        foreach ($queueEntries as $queueEntry) {
            $queueEntry->delete();
        }
    }

    /**
     * META METHOD: returns a list of orders to be processed
     * @param int $id force this Order to be processed
     * @param int $limit total number of orders that can be retrieved at any one time
     *
     * @return DataList (of orders)
     */
    public function OrdersToBeProcessed($id = 0, $limit = 9999)
    {

        //we sort the order randomly so that we get a nice mixture
        //not always the same ones holding up the process
        $sql = '
            SELECT "OrderID"
            FROM "OrderProcessQueue"
            WHERE
                "InProcess" = 0
                AND
                (UNIX_TIMESTAMP("Created") + "DeferTimeInSeconds") < UNIX_TIMESTAMP()
            ORDER BY '.$this->sortPhrase().'
            LIMIT '.$limit.';
        ';
        $rows = DB::query($sql);
        $orderIDs = array($id => $id);
        foreach ($rows as $row) {
            $orderIDs[$row['OrderID']] = $row['OrderID'];
        }

        return Order::get()
            ->filter(array('ID' => $orderIDs))
            ->sort($this->sortPhraseForOrderIDs($orderIDs));
    }

    /**
     * META METHOD: all orders with a queue object
     * @param int $id force this Order to be processed
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param int $limit total number of orders that can be retrieved at any one time
     *
     * @return DataList (of orders)
     */
    public function AllOrdersInQueue($limit = 9999)
    {
        $orderIDs = OrderProcessQueue::get()->column('OrderID');

        return Order::get()
            ->filter(array('ID' => $orderIDs))
            ->sort($this->sortPhraseForOrderIDs($orderIDs))
            ->limit($limit);
    }

    /**
     * META METHOD: returns a list of orders NOT YET to be processed
     * @param int $limit total number of orders that can be retrieved at any one time
     *
     * @return DataList (of orders)
     */
    public function OrdersInQueueThatAreNotReady($limit = 9999)
    {

        //we sort the order randomly so that we get a nice mixture
        //not always the same ones holding up the process
        $sql = '
            SELECT "OrderID"
            FROM "OrderProcessQueue"
            WHERE
                (UNIX_TIMESTAMP("Created") + "DeferTimeInSeconds") >= UNIX_TIMESTAMP()
            ORDER BY '.$this->sortPhrase().'
            LIMIT '.$limit.';
        ';
        $rows = DB::query($sql);
        $orderIDs = array(0 => 0);
        foreach ($rows as $row) {
            $orderIDs[$row['OrderID']] = $row['OrderID'];
        }

        return Order::get()
            ->filter(array('ID' => $orderIDs))
            ->sort($this->sortPhraseForOrderIDs($orderIDs));
    }

    /**
     * non-database method of working out if an Order is ready to go.
     *
     * @return bool
     */
    public function isReadyToGo()
    {
        return (strtotime($this->Created) + $this->DeferTimeInSeconds) < time();
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
    }

    /**
     *
     * casted variable
     * @return SS_DateTime
     */
    public function ToBeProcessedAt()
    {
        return $this->getToBeProcessedAt();
    }

    /**
     *
     * casted variable
     * @return SS_DateTime
     */
    public function getToBeProcessedAt()
    {
        return DBField::create_field('SS_Datetime', (strtotime($this->Created) + $this->DeferTimeInSeconds));
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
    }


    /**
     *
     * casted variable
     * @return SS_DateTime
     */
    public function HasBeenInQueueForSince()
    {
        return $this->getHasBeenInQueueForSince();
    }

    /**
     *
     * casted variable
     * @return SS_DateTime
     */
    public function getHasBeenInQueueForSince()
    {
        return DBField::create_field('SS_Datetime', (strtotime($this->Created)));
    }


    /**
     * CMS Fields
     * @return FieldList
     */
    public function getCMSFields()
    {
        $fields = parent::getCMSFields();
        if ($this->exists()) {
            $fields->addFieldToTab(
                'Root.Main',
                ReadonlyField::create(
                    'HasBeenInQueueForSinceCompilations',
                    _t('OrderProcessQueue.SINCE', 'In the queue since'),
                    $this->getHasBeenInQueueForSince()->Nice() . ' - ' . $this->getHasBeenInQueueForSince()->Ago()
                ),
                'DeferTimeInSeconds'
            );
            $fields->addFieldToTab(
                'Root.Main',
                ReadonlyField::create(
                    'ToBeProcessedAtCompilations',
                    _t('OrderProcessQueue.TO_BE_PROCESSED', 'To Be Processed'),
                    $this->getToBeProcessedAt()->Nice() . ' - ' . $this->getToBeProcessedAt()->Ago()
                ),
                'InProcess'
            );
            $fields->addFieldToTab(
                'Root.Main',
                LiteralField::create(
                    'processQueueNow',
                    '<h2>
                        <a href="/dev/tasks/EcommerceTaskProcessOrderQueue/?id='.$this->OrderID.'" target="_blank">'.
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                            _t('OrderProcessQueue.PROCESS', 'Process now').
                        '</a>
                    </h2>'
                )
            );
            $fields->replaceField(
                'OrderID',
                CMSEditLinkField::create(
                    'OrderID',
                    'Order',
                    $this->Order()
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
                )
            );
        }
        return $fields;
    }

    public function requireDefaultRecords()
    {
        parent::requireDefaultRecords();
        $errors = OrderProcessQueue::get()->filter(array('OrderID' => 0));
        foreach ($errors as $error) {
            DB::alteration_message(' DELETING ROGUE OrderProcessQueue', 'deleted');
            $error->delete();
        }
    }

    protected function sortPhrase()
    {
        return '
            "ProcessAttempts" ASC,
            (UNIX_TIMESTAMP("Created") + "DeferTimeInSeconds") ASC
        ';
    }

    /**
     * sort phrase for orders, based in order IDs...
     * @param  array $orderIds
/**
 * @param array $germany
 * @param array $ireland
 */
function finale($germany, $island) {
    return "2:1";
}
     * @return string
     */
    protected function sortPhraseForOrderIDs($orderIDs)
    {
        return 'FIELD("Order"."ID", '.implode(",", $orderIDs).')';
    }
}


1			<?php
2			/**
3			* This class provides a bunch of Meta Objects
4			* that do not interact with the object at hand, but rather with the datalist as a whole.
5			*
6			*/
7
8			class OrderProcessQueue extends DataObject
9			{
10			private static $db = array(
			0 ignored issues – show Comprehensibility introduced 2017-04-19 00:18 UTC by Report Bug Copy Issue Report Consider using a different property name as you override a private property of the parent class. Loading history...
11			'DeferTimeInSeconds' => 'Int',
12			'InProcess' => 'Boolean',
13			'ProcessAttempts' => 'Int'
14			);
15
16			private static $has_one = array(
			0 ignored issues – show Comprehensibility introduced 2017-04-19 00:18 UTC by Report Bug Copy Issue Report Consider using a different property name as you override a private property of the parent class. Loading history...
17			'Order' => 'Order',
18			'OrderStep' => 'OrderStep'
19			);
20
21			private static $indexes = array(
			0 ignored issues – show Comprehensibility introduced 2017-04-18 23:23 UTC by Report Bug Copy Issue Report Consider using a different property name as you override a private property of the parent class. Loading history...
22			'DeferTimeInSeconds' => true,
23			'ProcessAttempts' => true
24			);
25
26			private static $casting = array(
			0 ignored issues – show Comprehensibility introduced 2017-04-19 00:18 UTC by Report Bug Copy Issue Report Consider using a different property name as you override a private property of the parent class. Loading history...
27			'ToBeProcessedAt' => 'SS_Datetime',
28			'HasBeenInQueueSince' => 'SS_Datetime'
29			);
30
31			private static $default_sort = [
			0 ignored issues – show Comprehensibility introduced 2017-08-15 07:51 UTC by Report Bug Copy Issue Report Consider using a different property name as you override a private property of the parent class. Loading history...
32			'ID' => 'DESC'
33			];
34
35			/**

sunnysideup / silverstripe-ecommerce

OrderProcessQueue B last analyzed 2019-09-15 09:38 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

22 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like

OrderProcessQueue B
last analyzed 2019-09-15 09:38 UTC