luya\behaviors\JsonBehavior

Complexity

Total Complexity

13

Size/Duplication

Total Lines	96
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	events()	0	15	3
A	encodeAttributes()	0	18	5
A	decodeAttributes()	0	8	2
A	jsonEncode()	0	4	1
A	jsonDecode()	0	9	2

<?php

namespace luya\behaviors;

use luya\helpers\Json;
use yii\base\Behavior;
use yii\db\ActiveRecord;
use yii\db\BaseActiveRecord;

/**
 * Json Behavior.
 *
 * Provides auto encoding for array values after validation in order to store in the database.
 * 
 * In order to work only with arrayable json values use:
 * 
 * ```php
 * public function behaviors()
 * {
 *     return [
 *         'json' => [
 *             'class' => JsonBehavior:class,
 *             'attributes' => ['json_field'],
 *             'encodeBeforeValidate' => true,
 *             'decodeAfterFind' => true,
 *         ]
 *     ];
 * }
 * 
 * public function rules()
 * {
 *     return [
 *         [['json_field', 'each', 'rule' => ['safe']]]
 *     ]
 * }
 * ```
 *
 * @author Basil Suter <basil@nadar.io>
 * @since 1.0.9
 */
class JsonBehavior extends Behavior
{
    public $attributes = [];

    /**
     * @var boolean If enabled, the data will be encoded before validating, this means the validation rule should be `array` otherwise the validation must be `string`.
     * This might also differ based on how the data is passed to the model. Data passed to the model will be encoded from string to array (if not already).
     * @since 1.2.0 
     */
    public $encodeBeforeValidate = true;

    /**
     * @var boolean If enabled the data will be encoded from json to array after populating the active record data.
     * @since 1.2.0
     */
    public $decodeAfterFind = false;
    
    /**
     * @inheritdoc
     */
    public function events()
    {
        $events = [];
        if ($this->encodeBeforeValidate) {
            $events[ActiveRecord::EVENT_BEFORE_VALIDATE] = 'encodeAttributes';
        } else {
            $events[ActiveRecord::EVENT_AFTER_VALIDATE] = 'encodeAttributes';
        }

        if ($this->decodeAfterFind) {
            $events[ActiveRecord::EVENT_AFTER_FIND] = 'decodeAttributes';
        }

        return $events;
    }
    
    /**
     * Encode all attributes from json to php.
     */
    public function encodeAttributes()
    {
        foreach ($this->attributes as $name) {

            if ($this->owner instanceof BaseActiveRecord) {
                if (!isset($this->owner->getDirtyAttributes()[$name])) {
                    continue;
                }
            }
            
            
            $value = $this->owner->{$name};
            
            if (is_array($value)) {
                $this->owner->{$name} = $this->jsonEncode($value);
            }
        }
    }
    
    /**
     * Decode all attributes from php to json.
     */
    public function decodeAttributes()
    {
        foreach ($this->attributes as $name) {
            $value = $this->owner->{$name};
            
            $this->owner->{$name} = $this->jsonDecode($value);
        }
    }
    /**
     * Encodes the given value into a JSON string.
     *
     * @param mixed $value This is commonly an array.
     * @return string
     */
    public function jsonEncode($value)
    {
        return Json::encode($value);
    }
    
    /**
     * Decodes the given JSON string into a PHP data structure.
     *
     * @param string $value
     * @return array
     */
    public function jsonDecode($value)
    {
        // data is already passed by array
        if (is_array($value)) {
            return $value;
        }

        return Json::decode($value);
    }
}