ByTIC\Payments\Models\Tokens\TokensTrait

Complexity

Total Complexity

9

Size/Duplication

Total Lines	76
Duplicated Lines	0 %

Importance

Changes	4
Bugs	2	Features	2

7 Methods

Rating	Name	Duplication	Size	Complexity
A	initRelations()	0	3	1
A	initRelationsPurchase()	0	3	1
A	createForMethod()	0	8	1
A	initRelationsCommon()	0	4	1
A	injectParams()	0	5	1
A	generateTable()	0	3	1
A	findOrCreateForMethod()	0	15	3

<?php

namespace ByTIC\Payments\Models\Tokens;

use ByTIC\Omnipay\Common\Models\TokenInterface;
use ByTIC\Payments\Models\AbstractModels\HasCustomer\HasCustomerRepository;
use ByTIC\Payments\Models\AbstractModels\HasPaymentMethod\HasPaymentMethodRepository;
use ByTIC\Payments\Utility\PaymentsModels;
use Nip\Records\AbstractModels\Record;

/**
 * Trait TokensTrait
 * @package ByTIC\Payments\Models\Tokens
 *
 * @method TokenTrait|Token getNew
 */
trait TokensTrait
{
    use HasCustomerRepository;
    use HasPaymentMethodRepository;

    /**
     * @param $method
     * @param TokenInterface $token
     * @return TokenTrait|Record
     */
    public function findOrCreateForMethod($method, TokenInterface $token)
    {
        $findToken = $this->findOneByParams(

It seems like findOneByParams() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            [
                'where' => [
                    ['id_method =?', is_object($method) ? $method->id : $method],
                    ['token_id = ?', $token->getId()],
                ]
            ]);

        if ($findToken instanceof Record) {
            return $findToken;
        }

        return $this->createForMethod($method, $token);
    }

    /**
     * @param $method
     * @param TokenInterface $token
     * @return Token|TokenTrait
     */
    protected function createForMethod($method, TokenInterface $token)
    {
        $item = $this->getNew();
        $item->populateFromPaymentMethod($method);
        $item->populateFromGateway($method->getType()->getGateway());
        $item->populateFromToken($token);
        $item->insert();

It seems like insert() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        return $item;
    }

    protected function initRelations()
    {
        parent::initRelations();
    }

    protected function initRelationsCommon()
    {
        $this->initRelationsPurchase();
        $this->initRelationsPaymentMethod();
    }

    protected function initRelationsPurchase()
    {
        $this->belongsTo('Purchase', ['class' => get_class(PaymentsModels::purchases())]);

It seems like belongsTo() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * @param array $params
     */
    protected function injectParams(&$params = [])
    {
        $params['order'][] = ['created', 'desc'];

        parent::injectParams($params);
    }


    /**
     * @return mixed|\Nip\Config\Config
     * @throws \Exception
     */
    protected function generateTable()
    {
        return config('payments.tables.tokens', Tokens::TABLE);
    }
}