Completed
Push — develop ( e1fcb3...43936d )
by Nate
04:47
created

Domain::resolveField()   A

Complexity

Conditions 4
Paths 2

Size

Total Lines 14
Code Lines 8

Duplication

Lines 0
Ratio 0 %

Code Coverage

Tests 0
CRAP Score 20

Importance

Changes 0
Metric Value
dl 0
loc 14
ccs 0
cts 12
cp 0
rs 9.2
c 0
b 0
f 0
cc 4
eloc 8
nc 2
nop 1
crap 20
1
<?php
2
3
/**
4
 * @copyright  Copyright (c) Flipbox Digital Limited
5
 * @license    https://flipboxfactory.com/software/domains/license
6
 * @link       https://www.flipboxfactory.com/software/domains/
7
 */
8
9
namespace flipbox\domains\records;
10
11
use Craft;
12
use flipbox\craft\sortable\associations\records\SortableAssociation;
13
use flipbox\craft\sortable\associations\services\SortableAssociations;
14
use flipbox\domains\db\DomainsQuery;
15
use flipbox\domains\Domains as DomainsPlugin;
16
use flipbox\domains\fields\Domains;
17
use flipbox\domains\validators\DomainValidator;
18
use flipbox\ember\helpers\ModelHelper;
19
use flipbox\ember\traits\SiteRules;
20
use flipbox\ember\validators\LimitValidator;
21
use yii\base\InvalidArgumentException;
22
23
/**
24
 * @author Flipbox Factory <[email protected]>
25
 * @since  1.0.0
26
 *
27
 * @property int $fieldId
28
 * @property string $domain
29
 * @property int $elementId
30
 */
31
class Domain extends SortableAssociation
32
{
33
    use SiteRules;
34
35
    /**
36
     * @inheritdoc
37
     */
38
    const TABLE_ALIAS = 'domains';
39
40
    /**
41
     * @inheritdoc
42
     */
43
    const TARGET_ATTRIBUTE = 'domain';
44
45
    /**
46
     * @inheritdoc
47
     */
48
    const SOURCE_ATTRIBUTE = 'elementId';
49
50
    /**
51
     * @inheritdoc
52
     */
53
    protected function associationService(): SortableAssociations
54
    {
55
        return DomainsPlugin::getInstance()->getAssociations();
56
    }
57
58
    /**
59
     * {@inheritdoc}
60
     * @return DomainsQuery
61
     */
62
    public static function find()
63
    {
64
        return DomainsPlugin::getInstance()->getAssociations()->getQuery();
65
    }
66
67
    /**
68
     * @return array
69
     */
70
    public function rules(): array
71
    {
72
        return array_merge(
73
            parent::rules(),
74
            $this->siteRules(),
75
            [
76
                [
77
                    [
78
                        'status',
79
                        'fieldId',
80
                    ],
81
                    'required'
82
                ],
83
                [
84
                    [
85
                        'fieldId'
86
                    ],
87
                    'number',
88
                    'integerOnly' => true
89
                ],
90
                [
91
                    'domain',
92
                    DomainValidator::class
93
                ],
94
                [
95
                    'status',
96
                    'in',
97
                    'range' => array_keys(Domains::getStatuses())
98
                ],
99
                [
100
                    [
101
                        'fieldId'
102
                    ],
103
                    LimitValidator::class,
104
                    'query' => function (Domain $model) {
105
                        return $model::find()
106
                            ->field($model->fieldId)
107
                            ->element($model->elementId)
108
                            ->site($model->siteId)
109
                            ->andWhere([
110
                                '!=',
111
                                static::TARGET_ATTRIBUTE,
112
                                $model->{static::TARGET_ATTRIBUTE}
113
                            ]);
114
                    },
115
                    'limit' => function (Domain $model) {
116
                        return $this->getFieldLimit($model->fieldId);
117
                    },
118
                    'message' => "Limit exceeded."
119
                ],
120
                [
121
                    [
122
                        'fieldId',
123
                        'status',
124
                    ],
125
                    'safe',
126
                    'on' => [
127
                        ModelHelper::SCENARIO_DEFAULT
128
                    ]
129
                ]
130
            ]
131
        );
132
    }
133
134
    /**
135
     * @param int $fieldId
136
     * @return Domains
137
     */
138
    protected function resolveField(int $fieldId): Domains
139
    {
140
        $field = Craft::$app->getFields()->getFieldById($fieldId);
141
142
        if ($field === null || !$field instanceof Domains) {
143
            throw new InvalidArgumentException(sprintf(
144
                "Field must be an instance of '%s', '%s' given.",
145
                Domains::class,
146
                $field ? get_class($field) : 'FIELD NOT FOUND'
147
            ));
148
        }
149
150
        return $field;
151
    }
152
153
    /**
154
     * @param int $fieldId
155
     * @return int
156
     */
157
    protected function getFieldLimit(int $fieldId): int
158
    {
159
        return (int) $this->resolveField($fieldId)->limit;
160
    }
161
}
162