hipanel\modules\finance\cart\storage\RemoteCartStorage

Complexity

Total Complexity

27

Size/Duplication

Total Lines	202
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	8

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	read()	0	16	4
A	getSessionCartData()	0	9	2
A	mergeCartData()	0	7	1
A	getCacheKey()	0	4	1
A	getStorageKey()	0	4	1
A	write()	0	13	3
A	getIsActive()	0	4	1
A	open()	0	11	2
A	offsetExists()	0	6	1
A	offsetGet()	0	6	1
A	offsetSet()	0	6	1
A	offsetUnset()	0	5	1
A	throwShouldNotBeCalledException()	0	4	1
A	regenerateID()	0	4	1
A	readSession()	0	4	1
A	writeSession()	0	4	1
A	destroySession()	0	4	1
A	gcSession()	0	4	1
A	registerShutdownFunction()	0	4	1

<?php

namespace hipanel\modules\finance\cart\storage;

use hipanel\components\SettingsStorage;
use hipanel\helpers\StringHelper;
use Yii;
use yii\base\NotSupportedException;
use yii\caching\CacheInterface;
use yii\helpers\Json;
use yii\web\MultiFieldSession;
use yii\web\Session;
use yii\web\User;

/**
 * Class RemoteCartStorage
 *
 * @author Dmytro Naumenko <d.naumenko.a@gmail.com>
 */
class RemoteCartStorage extends MultiFieldSession implements CartStorageInterface
{
    /**
     * To marge sesstion and remote cart storage
     * @var string
     */
    public $sessionCartId;

    const CACHE_DURATION = 60 * 60; // 1 hour
    /**
     * @var array
     */
    protected $data = [];
    /**
     * @var array
     */
    protected $oldData = [];
    /**
     * @var SettingsStorage
     */
    private $settingsStorage;
    /**
     * @var CacheInterface
     */
    private $cache;
    /**
     * @var User
     */
    private $user;

    /**
     * @var Session
     */
    private $session;

    public function __construct(Session $session, User $user, SettingsStorage $settingsStorage, CacheInterface $cache, array $config = [])
    {
        parent::__construct($config);

        $this->settingsStorage = $settingsStorage;
        $this->cache = $cache;
        $this->user = $user;
        $this->session = $session;
    }

    protected function read()
    {
        try {
            $this->data = $this->cache->getOrSet($this->getCacheKey(), function () {

It seems like $this->cache->getOrSet($this->getCacheKey(), function () { $data = $this->settingsStorage->getBounded($this->getStorageKey()); $sessionCartData = $this->getSessionCartData(); if ($data === array() && $sessionCartData === array()) { return array(); } return $this->mergeCartData($data, $sessionCartData); }, self::CACHE_DURATION) of type * is incompatible with the declared type array of property $data.

                $data = $this->settingsStorage->getBounded($this->getStorageKey());
                $sessionCartData = $this->getSessionCartData();
                if ($data === [] && $sessionCartData === []) {
                    return [];
                }

                return $this->mergeCartData($data, $sessionCartData);
            }, self::CACHE_DURATION);
        } catch (\Exception $exception) {
            Yii::error('Failed to read cart: ' . $exception->getMessage(), __METHOD__);
        }
    }

    protected function getSessionCartData()
    {
        $result = [];
        if (isset($this->session[$this->sessionCartId])) {
            $result = unserialize($this->session[$this->sessionCartId]);
        }

        return $result;
    }

    protected function mergeCartData($remoteData, $sessionData)
    {
        $data = Json::decode(base64_decode($remoteData));
        $rawData = array_merge(unserialize($data[$this->sessionCartId]), $sessionData);

        return [$this->sessionCartId => serialize($rawData)];
    }

    protected function getCacheKey()
    {
        return [__CLASS__, $this->user->getId(), session_id()];
    }

    protected function getStorageKey()
    {
        return StringHelper::basename(__CLASS__);
    }

    protected function write()
    {
        if ($this->data === $this->oldData) {
            return;
        }

        try {
            $this->cache->set($this->getCacheKey(), $this->data);
            $this->settingsStorage->setBounded($this->getStorageKey(), base64_encode(Json::encode($this->data)));
        } catch (\Exception $exception) {
            Yii::error('Failed to save cart: ' . $exception->getMessage(), __METHOD__);
        }
    }

    /**
     * @var bool
     */
    private $_isActive;

    public function getIsActive()
    {
        return $this->_isActive;
    }

    /** {@inheritdoc} */
    public function open()
    {
        if ($this->getIsActive()) {
            return;
        }

        $this->read();
        $this->oldData = $this->data;
        $this->_isActive = true;
        $this->registerShutdownFunction();
    }

    /** {@inheritdoc} */
    public function offsetExists($offset)
    {
        $this->open();

        return isset($this->data[$offset]);
    }

    /** {@inheritdoc} */
    public function offsetGet($offset)
    {
        $this->open();

        return $this->data[$offset] ?? null;
    }

    /** {@inheritdoc} */
    public function offsetSet($offset, $item)
    {
        $this->open();

        $this->data[$offset] = $item;
    }

    /** {@inheritdoc} */
    public function offsetUnset($offset)
    {
        $this->open();
        unset($this->data[$offset]);
    }

    /**
     * @throws NotSupportedException
     * @void
     */
    private function throwShouldNotBeCalledException()
    {
        throw new NotSupportedException('Remote cart storage extends yii\web\Session, but it is not a session actually. This method should be never called.');
    }

    /** {@inheritdoc} */
    public function regenerateID($deleteOldSession = false)
    {
        $this->throwShouldNotBeCalledException();
    }

    /** {@inheritdoc} */
    public function readSession($id)
    {
        return $this->throwShouldNotBeCalledException();
    }

    /** {@inheritdoc} */
    public function writeSession($id, $data)
    {
        return $this->throwShouldNotBeCalledException();
    }

    /** {@inheritdoc} */
    public function destroySession($id)
    {
        return $this->throwShouldNotBeCalledException();
    }

    /** {@inheritdoc} */
    public function gcSession($maxLifetime)
    {
        return $this->throwShouldNotBeCalledException();
    }

    private function registerShutdownFunction()
    {
        register_shutdown_function(\Closure::fromCallable([$this, 'write']));
    }
}