Completed
Push — master ( 4a367e...23cbe7 )
by Taosikai
22:58 queued 07:56
created

RecurringApplicationChargeManager   A

Complexity

Total Complexity 8

Size/Duplication

Total Lines 74
Duplicated Lines 0 %

Coupling/Cohesion

Components 1
Dependencies 2

Importance

Changes 0
Metric Value
wmc 8
lcom 1
cbo 2
dl 0
loc 74
rs 10
c 0
b 0
f 0

8 Methods

Rating   Name   Duplication   Size   Complexity  
A getServiceName() 0 4 1
A getResourceName() 0 4 1
A getModelClass() 0 4 1
A count() 0 4 1
A remove() 0 4 1
A cancel() 0 4 1
A activate() 0 6 1
A customize() 0 10 1
1
<?php
2
3
/*
4
 * This file is part of the slince/shopify-api-php
5
 *
6
 * (c) Slince <[email protected]>
7
 *
8
 * This source file is subject to the MIT license that is bundled
9
 * with this source code in the file LICENSE.
10
 */
11
12
namespace Slince\Shopify\Manager\RecurringApplicationCharge;
13
14
use Slince\Shopify\Common\Manager\GeneralCurdable;
15
16
class RecurringApplicationChargeManager extends GeneralCurdable implements RecurringApplicationChargeManagerInterface
17
{
18
    /**
19
     * {@inheritdoc}
20
     */
21
    public static function getServiceName()
22
    {
23
        return 'recurring_application_charges';
24
    }
25
26
    /**
27
     * {@inheritdoc}
28
     */
29
    public function getResourceName()
30
    {
31
        return 'recurring_application_charge';
32
    }
33
34
    /**
35
     * {@inheritdoc}
36
     */
37
    public function getModelClass()
38
    {
39
        return RecurringApplicationCharge::class;
40
    }
41
42
    /**
43
     * {@inheritdoc}
44
     */
45
    public function count(array $query = [])
46
    {
47
        throw new \Exception('The action is not supported');
48
    }
49
50
    /**
51
     * {@inheritdoc}
52
     */
53
    public function remove($id)
54
    {
55
        throw new \Exception('The action is not supported');
56
    }
57
58
    /**
59
     * {@inheritdoc}
60
     */
61
    public function cancel($id)
62
    {
63
        parent::remove($id);
0 ignored issues
show
Comprehensibility Bug introduced by
It seems like you call parent on a different method (remove() instead of cancel()). Are you sure this is correct? If so, you might want to change this to $this->remove().

This check looks for a call to a parent method whose name is different than the method from which it is called.

Consider the following code:

class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}

The getFirstName() method in the Son calls the wrong method in the parent class.

Loading history...
64
    }
65
66
    /**
67
     * {@inheritdoc}
68
     */
69
    public function activate($id)
70
    {
71
        $data = $this->client->post('recurring_application_charges/'.$id.'/activate', []);
72
73
        return $this->fromArray(reset($data));
0 ignored issues
show
Bug Best Practice introduced by
The return type of return $this->fromArray(reset($data)); (Slince\Shopify\Common\Model\ModelInterface) is incompatible with the return type declared by the interface Slince\Shopify\Manager\R...agerInterface::activate of type Slince\Shopify\Recurring...urringApplicationCharge.

If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design.

Let’s take a look at an example:

class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}

Our function my_function expects a Post object, and outputs the author of the post. The base class Post returns a simple string and outputting a simple string will work just fine. However, the child class BlogPost which is a sub-type of Post instead decided to return an object, and is therefore violating the SOLID principles. If a BlogPost were passed to my_function, PHP would not complain, but ultimately fail when executing the strtoupper call in its body.

Loading history...
74
    }
75
76
    /**
77
     * {@inheritdoc}
78
     */
79
    public function customize($id, $cappedAmount)
80
    {
81
        $data = $this->client->post('recurring_application_charges/'.$id.'/customize', [], [
82
            $this->getResourceName() => [
83
                'capped_amount' => $cappedAmount
84
            ]
85
        ]);
86
87
        return $this->fromArray(reset($data));
0 ignored issues
show
Bug Best Practice introduced by
The return type of return $this->fromArray(reset($data)); (Slince\Shopify\Common\Model\ModelInterface) is incompatible with the return type declared by the interface Slince\Shopify\Manager\R...gerInterface::customize of type Slince\Shopify\Recurring...urringApplicationCharge.

If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design.

Let’s take a look at an example:

class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}

Our function my_function expects a Post object, and outputs the author of the post. The base class Post returns a simple string and outputting a simple string will work just fine. However, the child class BlogPost which is a sub-type of Post instead decided to return an object, and is therefore violating the SOLID principles. If a BlogPost were passed to my_function, PHP would not complain, but ultimately fail when executing the strtoupper call in its body.

Loading history...
88
    }
89
}