ReasonsService::getFieldUidById() - Code Metrics - mmikkel/Reasons-Craft3 - Measure and Improve Code Quality continuously with Scrutinizer

ReasonsService::getFieldUidById() A
last analyzed 2022-07-04 08:50 UTC

↳ Parent: ReasonsService

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
cc	2
eloc	6
c	3
b	0
f	0
nc	2
nop	1
dl	0
loc	10
rs	10

<?php
/**
 * Reasons plugin for Craft CMS 3.x
 *
 * Adds conditionals to field layouts.
 *
 * @link      https://vaersaagod.no
 * @copyright Copyright (c) 2020 Mats Mikkel Rummelhoff
 */

namespace mmikkel\reasons\services;

use Craft;
use craft\base\Field;
use craft\db\Query;
use craft\base\Component;
use craft\base\FieldInterface;
use craft\db\Table;
use craft\elements\User;
use craft\events\ConfigEvent;
use craft\events\RebuildConfigEvent;
use craft\fields\Assets;
use craft\fields\Categories;
use craft\fields\Checkboxes;
use craft\fields\Dropdown;
use craft\fields\Entries;
use craft\fields\Number;
use craft\fields\Lightswitch;
use craft\fields\MultiSelect;
use craft\fields\PlainText;
use craft\fields\RadioButtons;
use craft\fields\Tags;
use craft\fields\Users;
use craft\helpers\Db;
use craft\helpers\Json;
use craft\helpers\StringHelper;
use craft\models\FieldLayout;
use craft\records\EntryType;

use mmikkel\reasons\Reasons;

/**
 * @author    Mats Mikkel Rummelhoff
 * @package   Reasons
 * @since     2.0.0
 */
class ReasonsService extends Component
{

    /** @var int */
    const CACHE_TTL = 1800;

    /** @var Field[] */
    protected $allFields;

    /** @var Field[] */
    protected $toggleFields;

    /** @var array */
    protected $sources;

    /** @var int[] */
    protected $fieldIdsByUid;

    /** @var string[] */
    protected $fieldUidsById;

    // Public Methods
    // =========================================================================

    /**
     * Saves a field layout's conditionals, via the Project Config
     *
     * @param FieldLayout $layout
     * @param string|array $conditionals
     * @return bool
     * @throws \yii\base\ErrorException
     * @throws \yii\base\Exception
     * @throws \yii\base\NotSupportedException
     * @throws \yii\web\ServerErrorHttpException
     */
    public function saveFieldLayoutConditionals(FieldLayout $layout, $conditionals): bool
    {

        $uid = (new Query())
            ->select(['uid'])
            ->from('{{%reasons}}')
            ->where(['fieldLayoutId' => $layout->id])
            ->scalar();

        $isNew = !$uid;
        if ($isNew) {
            $uid = StringHelper::UUID();
        }

        $conditionals = $this->prepConditionalsForProjectConfig($conditionals);

        // Save it to the project config
        $path = "reasons_conditionals.{$uid}";
        Craft::$app->getProjectConfig()->set($path, [
            'fieldLayoutUid' => $layout->uid,
            'conditionals' => $conditionals,
        ]);

        return true;
    }

    /**
     * Deletes a field layout's conditionals, via the Project Config
     *
     * @param FieldLayout $layout
     * @return bool
     */
    public function deleteFieldLayoutConditionals(FieldLayout $layout): bool
    {

        $uid = (new Query())
            ->select(['uid'])
            ->from('{{%reasons}}')
            ->where(['fieldLayoutId' => $layout->id])
            ->scalar();

        if (!$uid) {
            return false;
        }

        // Remove it from the project config
        $path = "reasons_conditionals.{$uid}";
        Craft::$app->getProjectConfig()->remove($path);

        return true;
    }

    /**
     * @param ConfigEvent $event
     * @return void
     * @throws \Throwable
     * @throws \yii\db\Exception
     */
    public function onProjectConfigChange(ConfigEvent $event)
    {

        $this->clearCache();

        $uid = $event->tokenMatches[0];
        $data = $event->newValue;

        $id = (new Query())
            ->select(['id'])
            ->from('{{%reasons}}')
            ->where(['uid' => $uid])
            ->scalar();

        $isNew = empty($id);

        if ($isNew) {

            // Save new conditionals
            $fieldLayoutId = Db::idByUid(Table::FIELDLAYOUTS, $data['fieldLayoutUid']);

            if ($fieldLayoutId === null) {
                // The field layout might not've synced yet. Defer to Project Config
                Craft::$app->getProjectConfig()->defer($event, [$this, __FUNCTION__]);
                return;
            }

            $transaction = Craft::$app->getDb()->beginTransaction();

            try {
                Craft::$app->db->createCommand()
                    ->insert('{{%reasons}}', [
                        'fieldLayoutId' => $fieldLayoutId,
                        'conditionals' => $data['conditionals'],
                        'uid' => $uid,
                    ])
                    ->execute();
                $transaction->commit();
            } catch (\Throwable $e) {
                $transaction->rollBack();
                throw $e;
            }

        } else {

            // Update existing conditionals
            $transaction = Craft::$app->getDb()->beginTransaction();

            try {
                Craft::$app->db->createCommand()
                    ->update('{{%reasons}}', [
                        'conditionals' => $data['conditionals'],
                    ], ['id' => $id])
                    ->execute();
                $transaction->commit();
            } catch (\Throwable $e) {
                $transaction->rollBack();
                throw $e;
            }
        }

    }

    /**
     * @param ConfigEvent $event
     * @return void
     * @throws \Throwable
     * @throws \yii\db\Exception
     */
    public function onProjectConfigDelete(ConfigEvent $event)
    {

        $this->clearCache();

        $uid = $event->tokenMatches[0];

        $id = (new Query())
            ->select(['id'])
            ->from('{{%reasons}}')
            ->where(['uid' => $uid])
            ->scalar();

        if ($id) {

            $transaction = Craft::$app->getDb()->beginTransaction();

            try {
                Craft::$app->db->createCommand()
                    ->delete('{{%reasons}}', ['id' => $id])
                    ->execute();
                $transaction->commit();
            } catch (\Throwable $e) {
                $transaction->rollBack();
                throw $e;
            }
        }

    }

    /**
     * @param RebuildConfigEvent $event
     * @return void
     */
    public function onProjectConfigRebuild(RebuildConfigEvent $event)
    {

        Craft::$app->getProjectConfig()->remove('reasons_conditionals');

        $event->config['reasons_conditionals'] = [];

        $rows = (new Query())
            ->select(['reasons.uid', 'reasons.conditionals', 'fieldlayouts.uid AS fieldLayoutUid'])
            ->from('{{%reasons}} AS reasons')
            ->innerJoin(['fieldlayouts' => Table::FIELDLAYOUTS], '[[fieldlayouts.id]] = [[reasons.fieldLayoutId]]')
            ->all();

        foreach ($rows as $row) {
            $uid = $row['uid'] ?? null;
            $conditionals = $row['conditionals'] ?? null;
            $fieldLayoutUid = $row['fieldLayoutUid'] ?? null;
            if (!$uid || !$conditionals || !$fieldLayoutUid) {
                continue;
            }
            $event->config['reasons_conditionals'][$uid] = [
                'conditionals' => $conditionals,
                'fieldLayoutUid' => $fieldLayoutUid,
            ];
        }

        $this->clearCache();
    }

    /**
     * Clears Reasons' data caches
     *
     * @return void
     */
    public function clearCache()
    {
        Craft::$app->getCache()->delete($this->getCacheKey());
    }

    /**
     * @return array|mixed
     */
    public function getData()
    {
        $doCacheData = !Craft::$app->getConfig()->getGeneral()->devMode;
        $cacheKey = $this->getCacheKey();

        if ($doCacheData && $data = Craft::$app->getCache()->get($cacheKey)) {
            return $data;
        }

        $data = [
            'conditionals' => $this->getConditionals(),
            'toggleFieldTypes' => $this->getToggleFieldTypes(),
            'toggleFields' => $this->getToggleFields(),
            'fieldIds' => $this->getFieldIdsByHandle(),
        ];

        if ($doCacheData) {
            Craft::$app->getCache()->set($cacheKey, $data, self::CACHE_TTL);
        }

        return $data;
    }

    /**
     * @param string|array $conditionals
     * @return string|null
     */
    protected function prepConditionalsForProjectConfig($conditionals): ?string
    {
        if (!$conditionals) {
            return null;
        }
        $return = [];
        $conditionals = Json::decodeIfJson($conditionals);
        foreach ($conditionals as $targetFieldId => $statements) {
            $targetFieldId = (int)$targetFieldId;
            $targetFieldUid = $this->getFieldUidById($targetFieldId);
            $return[$targetFieldUid] = \array_map(function (array $rules) {
                return \array_map(function (array $rule) {
                    $fieldId = (int)$rule['fieldId'];
                    return [
                        'field' => $this->getFieldUidById($fieldId),
                        'compare' => $rule['compare'],
                        'value' => $rule['value'],
                    ];
                }, $rules);
            }, $statements);
        }
        return Json::encode($return);
    }

    /**
     * @param string|array $conditionals
     * @return array|null
     */
    protected function normalizeConditionalsFromProjectConfig($conditionals): ?array
    {
        if (!$conditionals) {
            return null;
        }
        $return = [];
        try {
            $conditionals = Json::decodeIfJson($conditionals);
            foreach ($conditionals as $targetFieldUid => $statements) {
                $targetFieldId = $this->getFieldIdByUid($targetFieldUid);
                $return["$targetFieldId"] = \array_map(function (array $rules) {
                    return \array_map(function (array $rule) {
                        $fieldUid = $rule['field'];
                        return [
                            'fieldId' => $this->getFieldIdByUid($fieldUid),
                            'compare' => $rule['compare'],
                            'value' => $rule['value'],
                        ];
                    }, $rules);
                }, $statements);
            }
        } catch (\Throwable $e) {
            Craft::error($e->getMessage(), __METHOD__);
        }
        return $return;
    }

    /**
     * Returns all conditionals, mapped by source key
     *
     * @return array
     */
    protected function getConditionals(): array
    {

        // Get all conditionals from database
        $rows = (new Query())
            ->select(['reasons.id', 'reasons.fieldLayoutId', 'reasons.conditionals'])
            ->from('{{%reasons}} AS reasons')
            ->innerJoin(['fieldlayouts' => Table::FIELDLAYOUTS], '[[fieldlayouts.id]] = [[reasons.fieldLayoutId]]')
            ->all();

        // Map conditionals to field layouts, and convert field uids to ids
        $conditionals = [];
        foreach ($rows as $row) {
            $conditionals["fieldLayout:{$row['fieldLayoutId']}"] = $this->normalizeConditionalsFromProjectConfig($row['conditionals']);
        }

        // Map conditionals to sources
        $conditionalsBySources = [];
        $sources = $this->getSources();
        foreach ($sources as $sourceId => $fieldLayoutId) {
            if (!isset($conditionals["fieldLayout:{$fieldLayoutId}"])) {
                continue;
            }
            $conditionalsBySources[$sourceId] = $conditionals["fieldLayout:{$fieldLayoutId}"];
        }

        return $conditionalsBySources;
    }

    /**
     * @return array
     */
    protected function getSources(): array
    {

        if (!isset($this->sources)) {

            $sources = [];

            $entryTypeRecords = EntryType::find()->all();
            /** @var EntryType $entryTypeRecord */
            foreach ($entryTypeRecords as $entryTypeRecord) {
                $sources["entryType:{$entryTypeRecord->id}"] = (int)$entryTypeRecord->fieldLayoutId;
                $sources["section:{$entryTypeRecord->sectionId}"] = (int)$entryTypeRecord->fieldLayoutId;
            }

            $categoryGroups = Craft::$app->getCategories()->getAllGroups();
            foreach ($categoryGroups as $categoryGroup) {
                $sources["categoryGroup:{$categoryGroup->id}"] = (int)$categoryGroup->fieldLayoutId;
            }

            $tagGroups = Craft::$app->getTags()->getAllTagGroups();
            foreach ($tagGroups as $tagGroup) {
                $sources["tagGroup:{$tagGroup->id}"] = (int)$tagGroup->fieldLayoutId;
            }

            $volumes = Craft::$app->getVolumes()->getAllVolumes();
            foreach ($volumes as $volume) {
                $sources["assetSource:{$volume->id}"] = (int)$volume->fieldLayoutId;
            }

            $globalSets = Craft::$app->getGlobals()->getAllSets();
            foreach ($globalSets as $globalSet) {
                $sources["globalSet:{$globalSet->id}"] = (int)$globalSet->fieldLayoutId;
            }

            $usersFieldLayout = Craft::$app->getFields()->getLayoutByType(User::class);
            $sources['users'] = $usersFieldLayout->id;

            $this->sources = $sources;

        }

        return $this->sources;
    }

    /**
     * Returns all toggleable fields
     *
     * @return array
     */
    protected function getToggleFields(): array
    {
        if (!isset($this->toggleFields)) {
            $this->toggleFields = [];
            $fields = $this->getAllFields();
            $toggleFieldTypes = $this->getToggleFieldTypes();
            foreach ($fields as $field) {
                $fieldType = \get_class($field);
                if (!\in_array($fieldType, $toggleFieldTypes)) {
                    continue;
                }
                $this->toggleFields[] = [
                    'id' => (int)$field->id,
                    'handle' => $field->handle,
                    'name' => $field->name,
                    'type' => $fieldType,
                    'settings' => $field->getSettings(),
                ];
            }
        }
        return $this->toggleFields;
    }

    /**
     * Returns all toggleable fieldtype classnames
     *
     * @return string[]
     */
    protected function getToggleFieldTypes(): array
    {
        return [
            Lightswitch::class,
            Dropdown::class,
            Checkboxes::class,
            MultiSelect::class,
            RadioButtons::class,
            Number::class,
            PlainText::class,
            Entries::class,
            Categories::class,
            Tags::class,
            Assets::class,
            Users::class,
        ];
    }

    /**
     * Returns all global field IDs, indexed by handle
     *
     * @return array
     */
    protected function getFieldIdsByHandle(): array
    {
        $handles = [];
        $fields = $this->getAllFields();
        foreach ($fields as $field) {
            $handles[$field->handle] = (int)$field->id;
        }
        return $handles;
    }

    /**
     * @return Field[]
     */
    protected function getAllFields(): array
    {
        if (!isset($this->allFields)) {
            $globalFields = Craft::$app->getFields()->getAllFields('global');
            $this->allFields = \array_filter($globalFields, function (FieldInterface $field) {
                return $field instanceof Field;
            });
        }
        return $this->allFields;
    }

    /**
     * Return the UID for a field, based on its database ID
     *
     * @param int $fieldId
     * @return string
     */
    protected function getFieldUidById(int $fieldId): string
    {
        if (!isset($this->fieldUidsById)) {
            $allFields = $this->getAllFields();
            $this->fieldUidsById = \array_reduce($allFields, function (array $carry, Field $field) {
                $carry["{$field->id}"] = $field->uid;
                return $carry;
            }, []);
        }
        return $this->fieldUidsById["$fieldId"];
    }

    /**
     * Return the database ID for a field, based on its UID
     *
     * @param string $fieldUid
     * @return int
     */
    protected function getFieldIdByUid(string $fieldUid): int
    {
        if (!isset($this->fieldIdsByUid)) {
            $allFields = $this->getAllFields();
            $this->fieldIdsByUid = \array_reduce($allFields, function (array $carry, Field $field) {
                $carry[$field->uid] = (int)$field->id;
                return $carry;
            }, []);
        }
        return $this->fieldIdsByUid[$fieldUid];
    }

    /**
     * @return string
     */
    protected function getCacheKey(): string
    {
        $reasons = Reasons::getInstance();
        return \implode('-', [
            $reasons->getHandle(),
            $reasons->getVersion(),
            $reasons->schemaVersion
        ]);
    }
}


1			<?php
2			/**
3			* Reasons plugin for Craft CMS 3.x
4			*
5			* Adds conditionals to field layouts.
6			*
7			* @link https://vaersaagod.no
8			* @copyright Copyright (c) 2020 Mats Mikkel Rummelhoff
9			*/
10
11			namespace mmikkel\reasons\services;
12
13			use Craft;
14			use craft\base\Field;
15			use craft\db\Query;
16			use craft\base\Component;
17			use craft\base\FieldInterface;
18			use craft\db\Table;
19			use craft\elements\User;
20			use craft\events\ConfigEvent;
21			use craft\events\RebuildConfigEvent;
22			use craft\fields\Assets;
23			use craft\fields\Categories;
24			use craft\fields\Checkboxes;
25			use craft\fields\Dropdown;
26			use craft\fields\Entries;
27			use craft\fields\Number;
28			use craft\fields\Lightswitch;
29			use craft\fields\MultiSelect;
30			use craft\fields\PlainText;
31			use craft\fields\RadioButtons;
32			use craft\fields\Tags;
33			use craft\fields\Users;
34			use craft\helpers\Db;
35			use craft\helpers\Json;
36			use craft\helpers\StringHelper;
37			use craft\models\FieldLayout;
38			use craft\records\EntryType;
39
40			use mmikkel\reasons\Reasons;
41
42			/**
43			* @author Mats Mikkel Rummelhoff
44			* @package Reasons
45			* @since 2.0.0
46			*/
47			class ReasonsService extends Component
48			{
49
50			/** @var int */
51			const CACHE_TTL = 1800;
52
53			/** @var Field[] */
54			protected $allFields;
55
56			/** @var Field[] */
57			protected $toggleFields;
58
59			/** @var array */
60			protected $sources;
61
62			/** @var int[] */
63			protected $fieldIdsByUid;
64
65			/** @var string[] */
66			protected $fieldUidsById;
67
68			// Public Methods
69			// =========================================================================
70
71			/**
72			* Saves a field layout's conditionals, via the Project Config
73			*
74			* @param FieldLayout $layout
75			* @param string\|array $conditionals
76			* @return bool
77			* @throws \yii\base\ErrorException
78			* @throws \yii\base\Exception
79			* @throws \yii\base\NotSupportedException
80			* @throws \yii\web\ServerErrorHttpException
81			*/
82			public function saveFieldLayoutConditionals(FieldLayout $layout, $conditionals): bool
83			{
84
85			$uid = (new Query())
86			->select(['uid'])
87			->from('{{%reasons}}')
88			->where(['fieldLayoutId' => $layout->id])
89			->scalar();
90
91			$isNew = !$uid;
92			if ($isNew) {
93			$uid = StringHelper::UUID();
94			}
95
96			$conditionals = $this->prepConditionalsForProjectConfig($conditionals);
97
98			// Save it to the project config
99			$path = "reasons_conditionals.{$uid}";
100			Craft::$app->getProjectConfig()->set($path, [
101			'fieldLayoutUid' => $layout->uid,
102			'conditionals' => $conditionals,
103			]);
104
105			return true;
106			}
107
108			/**
109			* Deletes a field layout's conditionals, via the Project Config
110			*
111			* @param FieldLayout $layout
112			* @return bool
113			*/
114			public function deleteFieldLayoutConditionals(FieldLayout $layout): bool
115			{
116
117			$uid = (new Query())
118			->select(['uid'])
119			->from('{{%reasons}}')
120			->where(['fieldLayoutId' => $layout->id])
121			->scalar();
122
123			if (!$uid) {
124			return false;
125			}
126
127			// Remove it from the project config
128			$path = "reasons_conditionals.{$uid}";
129			Craft::$app->getProjectConfig()->remove($path);
130
131			return true;
132			}
133
134			/**
135			* @param ConfigEvent $event
136			* @return void
137			* @throws \Throwable
138			* @throws \yii\db\Exception
139			*/
140			public function onProjectConfigChange(ConfigEvent $event)
141			{
142
143			$this->clearCache();
144
145			$uid = $event->tokenMatches[0];
146			$data = $event->newValue;
147
148			$id = (new Query())
149			->select(['id'])
150			->from('{{%reasons}}')
151			->where(['uid' => $uid])
152			->scalar();
153
154			$isNew = empty($id);
155
156			if ($isNew) {
157
158			// Save new conditionals
159			$fieldLayoutId = Db::idByUid(Table::FIELDLAYOUTS, $data['fieldLayoutUid']);
160
161			if ($fieldLayoutId === null) {
162			// The field layout might not've synced yet. Defer to Project Config
163			Craft::$app->getProjectConfig()->defer($event, [$this, __FUNCTION__]);
164			return;
165			}
166
167			$transaction = Craft::$app->getDb()->beginTransaction();
168
169			try {
170			Craft::$app->db->createCommand()
171			->insert('{{%reasons}}', [
172			'fieldLayoutId' => $fieldLayoutId,
173			'conditionals' => $data['conditionals'],
174			'uid' => $uid,
175			])
176			->execute();
177			$transaction->commit();
178			} catch (\Throwable $e) {
179			$transaction->rollBack();
180			throw $e;
181			}
182
183			} else {
184
185			// Update existing conditionals
186			$transaction = Craft::$app->getDb()->beginTransaction();
187
188			try {
189			Craft::$app->db->createCommand()
190			->update('{{%reasons}}', [
191			'conditionals' => $data['conditionals'],
192			], ['id' => $id])
193			->execute();
194			$transaction->commit();
195			} catch (\Throwable $e) {
196			$transaction->rollBack();
197			throw $e;
198			}
199			}
200
201			}
202
203			/**
204			* @param ConfigEvent $event
205			* @return void
206			* @throws \Throwable
207			* @throws \yii\db\Exception
208			*/
209			public function onProjectConfigDelete(ConfigEvent $event)
210			{
211
212			$this->clearCache();
213
214			$uid = $event->tokenMatches[0];
215
216			$id = (new Query())
217			->select(['id'])
218			->from('{{%reasons}}')
219			->where(['uid' => $uid])
220			->scalar();
221
222			if ($id) {
223
224			$transaction = Craft::$app->getDb()->beginTransaction();
225
226			try {
227			Craft::$app->db->createCommand()
228			->delete('{{%reasons}}', ['id' => $id])
229			->execute();
230			$transaction->commit();
231			} catch (\Throwable $e) {
232			$transaction->rollBack();
233			throw $e;
234			}
235			}
236
237			}
238
239			/**
240			* @param RebuildConfigEvent $event
241			* @return void
242			*/
243			public function onProjectConfigRebuild(RebuildConfigEvent $event)
244			{
245
246			Craft::$app->getProjectConfig()->remove('reasons_conditionals');
247
248			$event->config['reasons_conditionals'] = [];
249
250			$rows = (new Query())
251			->select(['reasons.uid', 'reasons.conditionals', 'fieldlayouts.uid AS fieldLayoutUid'])
252			->from('{{%reasons}} AS reasons')
253			->innerJoin(['fieldlayouts' => Table::FIELDLAYOUTS], '[[fieldlayouts.id]] = [[reasons.fieldLayoutId]]')
254			->all();
255
256			foreach ($rows as $row) {
257			$uid = $row['uid'] ?? null;
258			$conditionals = $row['conditionals'] ?? null;
259			$fieldLayoutUid = $row['fieldLayoutUid'] ?? null;
260			if (!$uid \|\| !$conditionals \|\| !$fieldLayoutUid) {
261			continue;
262			}
263			$event->config['reasons_conditionals'][$uid] = [
264			'conditionals' => $conditionals,
265			'fieldLayoutUid' => $fieldLayoutUid,
266			];
267			}
268
269			$this->clearCache();
270			}
271
272			/**
273			* Clears Reasons' data caches
274			*
275			* @return void
276			*/
277			public function clearCache()
278			{
279			Craft::$app->getCache()->delete($this->getCacheKey());
280			}
281
282			/**
283			* @return array\|mixed
284			*/
285			public function getData()
286			{
287			$doCacheData = !Craft::$app->getConfig()->getGeneral()->devMode;
288			$cacheKey = $this->getCacheKey();
289
290			if ($doCacheData && $data = Craft::$app->getCache()->get($cacheKey)) {
291			return $data;
292			}
293
294			$data = [
295			'conditionals' => $this->getConditionals(),
296			'toggleFieldTypes' => $this->getToggleFieldTypes(),
297			'toggleFields' => $this->getToggleFields(),
298			'fieldIds' => $this->getFieldIdsByHandle(),
299			];
300
301			if ($doCacheData) {
302			Craft::$app->getCache()->set($cacheKey, $data, self::CACHE_TTL);
303			}
304
305			return $data;
306			}
307
308			/**
309			* @param string\|array $conditionals
310			* @return string\|null
311			*/
312			protected function prepConditionalsForProjectConfig($conditionals): ?string
313			{
314			if (!$conditionals) {
315			return null;
316			}
317			$return = [];
318			$conditionals = Json::decodeIfJson($conditionals);
319			foreach ($conditionals as $targetFieldId => $statements) {
320			$targetFieldId = (int)$targetFieldId;
321			$targetFieldUid = $this->getFieldUidById($targetFieldId);
322			$return[$targetFieldUid] = \array_map(function (array $rules) {
323			return \array_map(function (array $rule) {
324			$fieldId = (int)$rule['fieldId'];
325			return [
326			'field' => $this->getFieldUidById($fieldId),
327			'compare' => $rule['compare'],
328			'value' => $rule['value'],
329			];
330			}, $rules);
331			}, $statements);
332			}
333			return Json::encode($return);
334			}
335
336			/**
337			* @param string\|array $conditionals
338			* @return array\|null
339			*/
340			protected function normalizeConditionalsFromProjectConfig($conditionals): ?array
341			{
342			if (!$conditionals) {
343			return null;
344			}
345			$return = [];
346			try {
347			$conditionals = Json::decodeIfJson($conditionals);
348			foreach ($conditionals as $targetFieldUid => $statements) {
349			$targetFieldId = $this->getFieldIdByUid($targetFieldUid);
350			$return["$targetFieldId"] = \array_map(function (array $rules) {
351			return \array_map(function (array $rule) {
352			$fieldUid = $rule['field'];
353			return [
354			'fieldId' => $this->getFieldIdByUid($fieldUid),
355			'compare' => $rule['compare'],
356			'value' => $rule['value'],
357			];
358			}, $rules);
359			}, $statements);
360			}
361			} catch (\Throwable $e) {
362			Craft::error($e->getMessage(), __METHOD__);
363			}
364			return $return;
365			}
366
367			/**
368			* Returns all conditionals, mapped by source key
369			*
370			* @return array
371			*/
372			protected function getConditionals(): array
373			{
374
375			// Get all conditionals from database
376			$rows = (new Query())
377			->select(['reasons.id', 'reasons.fieldLayoutId', 'reasons.conditionals'])
378			->from('{{%reasons}} AS reasons')
379			->innerJoin(['fieldlayouts' => Table::FIELDLAYOUTS], '[[fieldlayouts.id]] = [[reasons.fieldLayoutId]]')
380			->all();
381
382			// Map conditionals to field layouts, and convert field uids to ids
383			$conditionals = [];
384			foreach ($rows as $row) {
385			$conditionals["fieldLayout:{$row['fieldLayoutId']}"] = $this->normalizeConditionalsFromProjectConfig($row['conditionals']);
386			}
387
388			// Map conditionals to sources
389			$conditionalsBySources = [];
390			$sources = $this->getSources();
391			foreach ($sources as $sourceId => $fieldLayoutId) {
392			if (!isset($conditionals["fieldLayout:{$fieldLayoutId}"])) {
393			continue;
394			}
395			$conditionalsBySources[$sourceId] = $conditionals["fieldLayout:{$fieldLayoutId}"];
396			}
397
398			return $conditionalsBySources;
399			}
400
401			/**
402			* @return array
403			*/
404			protected function getSources(): array
405			{
406
407			if (!isset($this->sources)) {
408
409			$sources = [];
410
411			$entryTypeRecords = EntryType::find()->all();
412			/** @var EntryType $entryTypeRecord */
413			foreach ($entryTypeRecords as $entryTypeRecord) {
414			$sources["entryType:{$entryTypeRecord->id}"] = (int)$entryTypeRecord->fieldLayoutId;
415			$sources["section:{$entryTypeRecord->sectionId}"] = (int)$entryTypeRecord->fieldLayoutId;
416			}
417
418			$categoryGroups = Craft::$app->getCategories()->getAllGroups();
419			foreach ($categoryGroups as $categoryGroup) {
420			$sources["categoryGroup:{$categoryGroup->id}"] = (int)$categoryGroup->fieldLayoutId;
421			}
422
423			$tagGroups = Craft::$app->getTags()->getAllTagGroups();
424			foreach ($tagGroups as $tagGroup) {
425			$sources["tagGroup:{$tagGroup->id}"] = (int)$tagGroup->fieldLayoutId;
426			}
427
428			$volumes = Craft::$app->getVolumes()->getAllVolumes();
429			foreach ($volumes as $volume) {
430			$sources["assetSource:{$volume->id}"] = (int)$volume->fieldLayoutId;
431			}
432
433			$globalSets = Craft::$app->getGlobals()->getAllSets();
434			foreach ($globalSets as $globalSet) {
435			$sources["globalSet:{$globalSet->id}"] = (int)$globalSet->fieldLayoutId;
436			}
437
438			$usersFieldLayout = Craft::$app->getFields()->getLayoutByType(User::class);
439			$sources['users'] = $usersFieldLayout->id;
440
441			$this->sources = $sources;
442
443			}
444
445			return $this->sources;
446			}
447
448			/**
449			* Returns all toggleable fields
450			*
451			* @return array
452			*/
453			protected function getToggleFields(): array
454			{
455			if (!isset($this->toggleFields)) {
456			$this->toggleFields = [];
457			$fields = $this->getAllFields();
458			$toggleFieldTypes = $this->getToggleFieldTypes();
459			foreach ($fields as $field) {
460			$fieldType = \get_class($field);
461			if (!\in_array($fieldType, $toggleFieldTypes)) {
462			continue;
463			}
464			$this->toggleFields[] = [
465			'id' => (int)$field->id,
466			'handle' => $field->handle,
467			'name' => $field->name,
468			'type' => $fieldType,
469			'settings' => $field->getSettings(),
470			];
471			}
472			}
473			return $this->toggleFields;
474			}
475
476			/**
477			* Returns all toggleable fieldtype classnames
478			*
479			* @return string[]
480			*/
481			protected function getToggleFieldTypes(): array
482			{
483			return [
484			Lightswitch::class,
485			Dropdown::class,
486			Checkboxes::class,
487			MultiSelect::class,
488			RadioButtons::class,
489			Number::class,
490			PlainText::class,
491			Entries::class,
492			Categories::class,
493			Tags::class,
494			Assets::class,
495			Users::class,
496			];
497			}
498
499			/**
500			* Returns all global field IDs, indexed by handle
501			*
502			* @return array
503			*/
504			protected function getFieldIdsByHandle(): array
505			{
506			$handles = [];
507			$fields = $this->getAllFields();
508			foreach ($fields as $field) {
509			$handles[$field->handle] = (int)$field->id;
510			}
511			return $handles;
512			}
513
514			/**
515			* @return Field[]
516			*/
517			protected function getAllFields(): array
518			{
519			if (!isset($this->allFields)) {
520			$globalFields = Craft::$app->getFields()->getAllFields('global');
521			$this->allFields = \array_filter($globalFields, function (FieldInterface $field) {
522			return $field instanceof Field;
523			});
524			}
525			return $this->allFields;
526			}
527
528			/**
529			* Return the UID for a field, based on its database ID
530			*
531			* @param int $fieldId
532			* @return string
533			*/
534			protected function getFieldUidById(int $fieldId): string
535			{
536			if (!isset($this->fieldUidsById)) {
537			$allFields = $this->getAllFields();
538			$this->fieldUidsById = \array_reduce($allFields, function (array $carry, Field $field) {
539			$carry["{$field->id}"] = $field->uid;
540			return $carry;
541			}, []);
542			}
543			return $this->fieldUidsById["$fieldId"];
544			}
545
546			/**
547			* Return the database ID for a field, based on its UID
548			*
549			* @param string $fieldUid
550			* @return int
551			*/
552			protected function getFieldIdByUid(string $fieldUid): int
553			{
554			if (!isset($this->fieldIdsByUid)) {
555			$allFields = $this->getAllFields();
556			$this->fieldIdsByUid = \array_reduce($allFields, function (array $carry, Field $field) {
557			$carry[$field->uid] = (int)$field->id;
558			return $carry;
559			}, []);
560			}
561			return $this->fieldIdsByUid[$fieldUid];
562			}
563
564			/**
565			* @return string
566			*/
567			protected function getCacheKey(): string
568			{
569			$reasons = Reasons::getInstance();
570			return \implode('-', [
571			$reasons->getHandle(),
572			$reasons->getVersion(),
573			$reasons->schemaVersion
574			]);
575			}
576			}
577

mmikkel / Reasons-Craft3

ReasonsService::getFieldUidById() A last analyzed 2022-07-04 08:50 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

ReasonsService::getFieldUidById() A
last analyzed 2022-07-04 08:50 UTC