Jidaikobo\Kontiki\Models\Traits\CRUDTrait

Complexity

Total Complexity

35

Size/Duplication

Total Lines	196
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	getById()	0	20	4
A	processDataBeforeSave()	0	14	4
A	filterAllowedFields()	0	4	1
A	getByFieldWithCondtioned()	0	18	3
A	afterProcessDataBeforeGet()	0	3	1
A	processDataForForm()	0	3	1
A	getByField()	0	14	3
A	processDataBeforeGet()	0	11	4
A	delete()	0	8	2
A	create()	0	11	3
A	getDataForForm()	0	7	3
A	afterProcessDataBeforeSave()	0	3	1
A	update()	0	12	2
A	setPosttypeBeforeSave()	0	10	3

<?php

namespace Jidaikobo\Kontiki\Models\Traits;

use Carbon\Carbon;
use  Jidaikobo\Kontiki\Managers\FlashManager;

trait CRUDTrait
{
    public function getById(int $id): ?array
    {
        $result = $this->db->table($this->table)
            ->where('id', $id)
            ->first();

        if ($result === null) {
            return null;
        }

        $result = (array)$result;

        if (method_exists($this, 'getAllMetaData')) {
            $metaData = $this->getAllMetaData($id);
            $result = array_merge($result, $metaData);
        }

        $result = $this->processDataBeforeGet($result);

        return $result ? (array)$result : null;
    }

    public function getByField(string $field, mixed $value): ?array
    {
        $result = $this->db->table($this->table)
            ->where($field, $value)
            ->first();

        if ($result === null) {
            return null;
        }

        $result = (array)$result;
        $result = $this->processDataBeforeGet($result);

        return $result ? (array)$result : null;
    }

    public function getByFieldWithCondtioned(
        string $field,
        mixed $value,
        string $context = 'published'
    ): ?array {
        $query = $this->getQuery();

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

        $query = $this->getAdditionalConditions($query, $context);

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

        $result = $query
            ->where($field, $value)
            ->where('post_type', $this->postType)
            ->first();

        if (is_object($result)) {
            $result = (array)$result;
            $result = $this->processDataBeforeGet($result);
        }

        return $result ? (array)$result : null;
    }

    public function getDataForForm(
        string $actionType,
        FlashManager $flashManager,
        ?int $id = null
    ): array {
        $data = $flashManager->getData('data') ?: ($id ? $this->getById($id) : []);
        return $this->processDataForForm($actionType, $data);

It seems like $data can also be of type null; however, parameter $data of Jidaikobo\Kontiki\Models\Traits\CRUDTrait::processDataForForm() does only seem to accept array, maybe add an additional type check?

    }

    protected function processDataForForm(string $actionType, array $data): array

The parameter $actionType is not used and could be removed.

    {
        return $data;
    }

    protected function setPosttypeBeforeSave(array $data): array
    {
        $post_type = $data['post_type'] ?? '';
        if (!empty($post_type)) {
            return $data;
        }
        if (!empty($this->postType)) {
            $data['post_type'] = $this->postType;
        }
        return $data;
    }

    protected function processDataBeforeSave(string $context, array $data): array
    {
        foreach ($data as $field => $value) {
            $saveAsUtc = $this->getFieldDefinitions()[$field]['save_as_utc'] ?? false;

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

            if ($saveAsUtc) {
                if (empty($value)) {
                    $data[$field] = null;
                } else {
                    $date = Carbon::parse($value, env('TIMEZONE', 'UTC'))->setTimezone('UTC');
                    $data[$field] = $date->format('Y-m-d H:i:s');
                }
            }
        }
        return $this->afterProcessDataBeforeSave($context, $data);
    }

    protected function processDataBeforeGet(array $data): array
    {
        foreach ($data as $field => $value) {
            $saveAsUtc = $this->getFieldDefinitions()[$field]['save_as_utc'] ?? false;
            if ($saveAsUtc && !empty($value)) {
                $date = Carbon::parse($value, 'UTC')->setTimezone(env('TIMEZONE', 'UTC'));
                $data[$field] = $date->format('Y-m-d H:i:s');
            }
        }

        return $this->afterProcessDataBeforeGet($data);
        ;
    }

    protected function afterProcessDataBeforeSave(string $context, array $data): array

The parameter $context is not used and could be removed.

    {
        return $data;
    }

    protected function afterProcessDataBeforeGet(array $data): array
    {
        return $data;
    }

    /**
     * Filter the given data array to include only allowed fields.
     *
     * @param array $data The data to filter.
     *
     * @return array The filtered data.
     */
    public function filterAllowedFields(array $data): array
    {
        $allowedFields = array_keys($this->getFieldDefinitions());
        return array_intersect_key($data, array_flip($allowedFields));
    }

    /**
     * Create a new record in the table.
     *
     * @param array $data Key-value pairs of column names and values.
     *
     * @return int|null The ID of the newly created record, or null if the operation failed.
     */
    public function create(array $data, bool $skipFieldFilter = false): ?int
    {
        if (!$skipFieldFilter) {
            $data = $this->filterAllowedFields($data);
        }

        $data = $this->processDataBeforeSave('create', $data);
        $data = $this->setPosttypeBeforeSave($data);

        $success = $this->db->table($this->table)->insert($data);
        return $success ? (int) $this->db->getPdo()->lastInsertId() : null;
    }

    /**
     * Update a record in the table by its ID.
     *
     * @param  int   $id   The ID of the record to update.
     * @param  array $data Key-value pairs of column names and values to update.
     *
     * @return bool True if the record was updated, false otherwise.
     */
    public function update(int $id, array $data, bool $skipFieldFilter = false): bool
    {
        if (!$skipFieldFilter) {
            $data = $this->filterAllowedFields($data);
        }

        $data = $this->processDataBeforeSave('update', $data);
        $data = $this->setPosttypeBeforeSave($data);

        return (bool) $this->db->table($this->table)
            ->where('id', $id)
            ->update($data);
    }

    /**
     * Delte a record in the table by its ID.
     *
     * @param  int   $id   The ID of the record to update.
     *
     * @return bool True if the record was updated, false otherwise.
     */
    public function delete(int $id): bool
    {
        if (!$this->getById($id)) {
            return false;
        }
        return (bool)$this->db->table($this->table)
            ->where('id', $id)
            ->delete();
    }
}