Dynamic\FoxyStripe\Model\Order

Complexity

Total Complexity

28

Size/Duplication

Total Lines	357
Duplicated Lines	0 %

Test Coverage

Coverage

40%

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	canEdit()	0	3	1
A	fieldLabels()	0	18	1
A	parseOrder()	0	12	2
A	parseOrderInfo()	0	14	2
A	ReceiptLink()	0	3	1
A	getReceiptLink()	0	8	1
A	providePermissions()	0	4	1
A	onBeforeWrite()	0	4	1
A	canCreate()	0	3	1
A	getDecryptedResponse()	0	7	2
B	parseOrderDetails()	0	54	8
A	canView()	0	3	1
A	canDelete()	0	3	1
B	parseOrderCustomer()	0	31	5

<?php

namespace Dynamic\FoxyStripe\Model;

use Dynamic\FoxyStripe\Page\ProductPage;
use SilverStripe\Core\Config\Config;
use SilverStripe\Forms\DateField;
use SilverStripe\ORM\DataObject;
use SilverStripe\ORM\FieldType\DBHTMLVarchar;
use SilverStripe\Security\Member;
use SilverStripe\Security\Permission;
use SilverStripe\Security\PermissionProvider;
use SilverStripe\Security\Security;

/**
 * Class Order
 * @package Dynamic\FoxyStripe\Model
 *
 * @property \SilverStripe\ORM\FieldType\DBInt Order_ID
 * @property \SilverStripe\ORM\FieldType\DBDatetime TransactionDate
 * @property \SilverStripe\ORM\FieldType\DBCurrency ProductTotal
 * @property \SilverStripe\ORM\FieldType\DBCurrency TaxTotal
 * @property \SilverStripe\ORM\FieldType\DBCurrency ShippingTotal
 * @property \SilverStripe\ORM\FieldType\DBCurrency OrderTotal
 * @property \SilverStripe\ORM\FieldType\DBVarchar ReceiptURL
 * @property \SilverStripe\ORM\FieldType\DBVarchar OrderStatus
 * @property \SilverStripe\ORM\FieldType\DBVarchar Response
 *
 * @property int MemberID
 * @method Member Member
 *
 * @method \SilverStripe\ORM\HasManyList Details
 */
class Order extends DataObject implements PermissionProvider
{
    /**
     * @var array
     */
    private static $db = array(

The private property $db is not used, and could be removed.

        'Order_ID' => 'Int',
        'TransactionDate' => 'DBDatetime',
        'ProductTotal' => 'Currency',
        'TaxTotal' => 'Currency',
        'ShippingTotal' => 'Currency',
        'OrderTotal' => 'Currency',
        'ReceiptURL' => 'Varchar(255)',
        'OrderStatus' => 'Varchar(255)',
        'Response' => 'Text',
    );

    /**
     * @var array
     */
    private static $has_one = array(

The private property $has_one is not used, and could be removed.

        'Member' => Member::class,
    );

    /**
     * @var array
     */
    private static $has_many = array(

The private property $has_many is not used, and could be removed.

        'Details' => OrderDetail::class,
    );

    /**
     * @var string
     */
    private static $singular_name = 'Order';

The private property $singular_name is not used, and could be removed.

    /**
     * @var string
     */
    private static $plural_name = 'Orders';

The private property $plural_name is not used, and could be removed.

    /**
     * @var string
     */
    private static $description = 'Orders from FoxyCart Datafeed';

The private property $description is not used, and could be removed.

    /**
     * @var string
     */
    private static $default_sort = 'TransactionDate DESC, ID DESC';

The private property $default_sort is not used, and could be removed.

    /**
     * @var array
     */
    private static $summary_fields = array(

The private property $summary_fields is not used, and could be removed.

        'Order_ID',
        'TransactionDate.NiceUS',
        'Member.Name',
        'ProductTotal.Nice',
        'ShippingTotal.Nice',
        'TaxTotal.Nice',
        'OrderTotal.Nice',
        'ReceiptLink',
    );

    /**
     * @var array
     */
    private static $searchable_fields = array(

The private property $searchable_fields is not used, and could be removed.

        'Order_ID',
        'TransactionDate' => array(
            'field' => DateField::class,
            'filter' => 'PartialMatchFilter',
        ),
        'Member.ID',
        'OrderTotal',
        'Details.ProductID',
    );

    /**
     * @var array
     */
    private static $casting = array(

The private property $casting is not used, and could be removed.

        'ReceiptLink' => 'HTMLVarchar',
    );

    /**
     * @var array
     */
    private static $indexes = array(

The private property $indexes is not used, and could be removed.

        'Order_ID' => true, // make unique
    );

    /**
     * @var string
     */
    private static $table_name = 'FS_Order';

The private property $table_name is not used, and could be removed.

    /**
     * @param bool $includerelations
     *
     * @return array|string
     */
    public function fieldLabels($includerelations = true)
    {
        $labels = parent::fieldLabels();

        $labels['Order_ID'] = _t('Order.Order_ID', 'Order ID#');
        $labels['TransactionDate'] = _t('Order.TransactionDate', 'Date');
        $labels['TransactionDate.NiceUS'] = _t('Order.TransactionDate', 'Date');
        $labels['Member.Name'] = _t('Order.MemberName', 'Customer');
        $labels['Member.ID'] = _t('Order.MemberName', 'Customer');
        $labels['ProductTotal.Nice'] = _t('Order.ProductTotal', 'Sub Total');
        $labels['TaxTotal.Nice'] = _t('Order.TaxTotal', 'Tax');
        $labels['ShippingTotal.Nice'] = _t('Order.ShippingTotal', 'Shipping');
        $labels['OrderTotal'] = _t('Order.OrderTotal', 'Total');
        $labels['OrderTotal.Nice'] = _t('Order.OrderTotal', 'Total');
        $labels['ReceiptLink'] = _t('Order.ReceiptLink', 'Invoice');
        $labels['Details.ProductID'] = _t('Order.Details.ProductID', 'Product');

        return $labels;
    }

    /**
     * @return mixed
     */
    public function ReceiptLink()
    {
        return $this->getReceiptLink();
    }

    /**
     * @return mixed
     */
    public function getReceiptLink()
    {
        $obj = DBHTMLVarchar::create();
        $obj->setValue(
            '<a href="'.$this->ReceiptURL.'" target="_blank" class="cms-panel-link action external-link">view</a>'
        );

        return $obj;
    }

    /**
     * @return string|bool
     */
    public function getDecryptedResponse()
    {
        $decrypted = urldecode($this->Response);
        if (FoxyCart::getStoreKey()) {
            return \rc4crypt::decrypt(FoxyCart::getStoreKey(), $decrypted);

The type rc4crypt was not found. Maybe you did not declare it correctly or list all dependencies?

        }
        return false;
    }

    /**
     * @throws \SilverStripe\ORM\ValidationException
     */
    public function onBeforeWrite()
    {
        $this->parseOrder();
        parent::onBeforeWrite();
    }

    /**
     * @return bool
     *
     * @throws \SilverStripe\ORM\ValidationException
     */
    public function parseOrder()
    {
        if ($this->getDecryptedResponse()) {
            $response = new \SimpleXMLElement($this->getDecryptedResponse());

It seems like $this->getDecryptedResponse() can also be of type true; however, parameter $data of SimpleXMLElement::__construct() does only seem to accept string, maybe add an additional type check?

            $this->parseOrderInfo($response);
            $this->parseOrderCustomer($response);
            $this->parseOrderDetails($response);

            return true;
        } else {
            return false;
        }
    }

    /**
     * @param $response
     */
    public function parseOrderInfo($response)
    {
        foreach ($response->transactions->transaction as $transaction) {
            // Record transaction data from FoxyCart Datafeed:
            $this->Store_ID = (int) $transaction->store_id;

The property Store_ID does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

            $this->TransactionDate = (string) $transaction->transaction_date;

It seems like (string)$transaction->transaction_date of type string is incompatible with the declared type SilverStripe\ORM\FieldType\DBDatetime of property $TransactionDate.

            $this->ProductTotal = (float) $transaction->product_total;

It seems like (double)$transaction->product_total of type double is incompatible with the declared type SilverStripe\ORM\FieldType\DBCurrency of property $ProductTotal.

            $this->TaxTotal = (float) $transaction->tax_total;

It seems like (double)$transaction->tax_total of type double is incompatible with the declared type SilverStripe\ORM\FieldType\DBCurrency of property $TaxTotal.

            $this->ShippingTotal = (float) $transaction->shipping_total;

It seems like (double)$transaction->shipping_total of type double is incompatible with the declared type SilverStripe\ORM\FieldType\DBCurrency of property $ShippingTotal.

            $this->OrderTotal = (float) $transaction->order_total;

It seems like (double)$transaction->order_total of type double is incompatible with the declared type SilverStripe\ORM\FieldType\DBCurrency of property $OrderTotal.

            $this->ReceiptURL = (string) $transaction->receipt_url;

It seems like (string)$transaction->receipt_url of type string is incompatible with the declared type SilverStripe\ORM\FieldType\DBVarchar of property $ReceiptURL.

            $this->OrderStatus = (string) $transaction->status;

It seems like (string)$transaction->status of type string is incompatible with the declared type SilverStripe\ORM\FieldType\DBVarchar of property $OrderStatus.

            $this->extend('handleOrderInfo', $order, $response);
        }
    }

    /**
     * @param $response
     * @throws \SilverStripe\ORM\ValidationException
     */
    public function parseOrderCustomer($response)
    {
        foreach ($response->transactions->transaction as $transaction) {
            // if not a guest transaction in FoxyCart
            if (isset($transaction->customer_email) && $transaction->is_anonymous == 0) {
                // if Customer is existing member, associate with current order
                if (Member::get()->filter('Email', $transaction->customer_email)->First()) {
                    $customer = Member::get()->filter('Email', $transaction->customer_email)->First();
                    // if new customer, create account with data from FoxyCart
                } else {
                    // set PasswordEncryption to 'none' so imported, encrypted password is not encrypted again
                    Config::modify()->set(Security::class, 'password_encryption_algorithm', 'none');

                    // create new Member, set password info from FoxyCart
                    $customer = Member::create();
                    $customer->Customer_ID = (int) $transaction->customer_id;
                    $customer->FirstName = (string) $transaction->customer_first_name;
                    $customer->Surname = (string) $transaction->customer_last_name;
                    $customer->Email = (string) $transaction->customer_email;
                    $customer->Password = (string) $transaction->customer_password;
                    $customer->Salt = (string) $transaction->customer_password_salt;
                    $customer->PasswordEncryption = 'none';

                    // record member record
                    $customer->write();
                }

                // set Order MemberID
                $this->MemberID = $customer->ID;

                $this->extend('handleOrderCustomer', $order, $response, $customer);
            }
        }
    }

    /**
     * @param $response
     *
     * @throws \SilverStripe\ORM\ValidationException
     */
    public function parseOrderDetails($response)
    {

        // remove previous OrderDetails and OrderOptions so we don't end up with duplicates
        foreach ($this->Details() as $detail) {
            /** @var OrderOption $orderOption */
            foreach ($detail->OrderOptions() as $orderOption) {
                $orderOption->delete();
            }
            $detail->delete();
        }

        foreach ($response->transactions->transaction as $transaction) {
            // Associate ProductPages, Options, Quantity with Order
            foreach ($transaction->transaction_details->transaction_detail as $detail) {
                $OrderDetail = OrderDetail::create();

                $OrderDetail->Quantity = (int) $detail->product_quantity;
                $OrderDetail->ProductName = (string) $detail->product_name;
                $OrderDetail->ProductCode = (string) $detail->product_code;
                $OrderDetail->ProductImage = (string) $detail->image;
                $OrderDetail->ProductCategory = (string) $detail->category_code;
                $priceModifier = 0;

                // parse OrderOptions
                foreach ($detail->transaction_detail_options->transaction_detail_option as $option) {
                    // Find product via product_id custom variable
                    if ($option->product_option_name == 'product_id') {
                        // if product is found, set relation to OrderDetail
                        $OrderProduct = ProductPage::get()->byID((int) $option->product_option_value);
                        if ($OrderProduct) {
                            $OrderDetail->ProductID = $OrderProduct->ID;
                        }
                    } else {
                        $OrderOption = OrderOption::create();
                        $OrderOption->Name = (string) $option->product_option_name;
                        $OrderOption->Value = (string) $option->product_option_value;
                        $OrderOption->write();
                        $OrderDetail->OrderOptions()->add($OrderOption);

                        $priceModifier += $option->price_mod;
                    }
                }

                $OrderDetail->Price = (float) $detail->product_price + (float) $priceModifier;

                // extend OrderDetail parsing, allowing for recording custom fields from FoxyCart
                $this->extend('handleOrderItem', $order, $response, $OrderDetail);

                // write
                $OrderDetail->write();

                // associate with this order
                $this->Details()->add($OrderDetail);
            }
        }
    }

    /**
     * @param bool $member
     *
     * @return bool|int
     */
    public function canView($member = null)
    {
        return Permission::check('Product_ORDERS', 'any', $member);

It seems like $member can also be of type boolean; however, parameter $member of SilverStripe\Security\Permission::check() does only seem to accept SilverStripe\Security\Member|integer, maybe add an additional type check?

    }

    /**
     * @param null $member

Are you sure the doc-type for parameter $member is correct as it would always require null to be passed?

     *
     * @return bool
     */
    public function canEdit($member = null)
    {
        return false;
        //return Permission::check('Product_ORDERS', 'any', $member);

67% of this comment could be valid code. Did you maybe forget this after debugging?

    }

    /**
     * @param null $member

Are you sure the doc-type for parameter $member is correct as it would always require null to be passed?

     *
     * @return bool
     */
    public function canDelete($member = null)
    {
        return false;
        //return Permission::check('Product_ORDERS', 'any', $member);

67% of this comment could be valid code. Did you maybe forget this after debugging?

    }

    /**
     * @param null  $member

Are you sure the doc-type for parameter $member is correct as it would always require null to be passed?

     * @param array $context
     *
     * @return bool
     */
    public function canCreate($member = null, $context = [])
    {
        return false;
    }

    /**
     * @return array
     */
    public function providePermissions()
    {
        return array(
            'Product_ORDERS' => 'Allow user to manage Orders and related objects',
        );
    }
}