# fluent-cart/1.6.4/api/Resource/BaseResourceApi.php

FluentCart A New Era of eCommerce – Faster, Lighter, and Simpler, version 1.6.4. 131 lines.

- Page: https://pluginprobe.com/plugins/fluent-cart/1.6.4/code/api/Resource/BaseResourceApi.php
- Raw: https://pluginprobe.com/plugins/fluent-cart/1.6.4/raw/api/Resource/BaseResourceApi.php
- Modified: 2026-08-11T13:30:16+00:00

Line numbers below start at 1. Link to a line or a range by appending a fragment to the
page URL, for example `https://pluginprobe.com/plugins/fluent-cart/1.6.4/code/api/Resource/BaseResourceApi.php#L10-L20`.

```php
<?php

namespace FluentCart\Api\Resource;

use BadMethodCallException;
use FluentCart\Framework\Database\Orm\Builder;
use FluentCart\Framework\Foundation\App;
use FluentCart\Framework\Http\Response\Response;
use FluentCart\Framework\Pagination\AbstractPaginator;
use FluentCart\Framework\Support\Arr;
use WP_Error;


abstract class BaseResourceApi
{
    /**
     * Request Instance
     * @var Response $response
     */
    protected $response = null;

    public static function __callStatic($method, $params)
    {
        $class = static::class;

        if (method_exists($class, $method . 'Authorized')) {
            return call_user_func_array(array(new $class, $method . 'Authorized'), $params);
        } else {
            throw new BadMethodCallException();
        }

    }

    public function __construct()
    {
        $this->response = App::getInstance()['response'];
    }

    /*
     * @return mixed
     */
    abstract public static function get(array $params = []);

    abstract public static function find($id, $params = []);

    private static function findUsing($query): Builder
    {
        return static::getQuery()->search($query);
    }

    public static function search($query, ?callable $modifyQueryUsing = null, $asCollection = false)
    {
        $query = static::findUsing($query);
        if (is_callable($modifyQueryUsing)) {
            $modifiedQuery = $modifyQueryUsing($query);
            if (is_object($modifiedQuery) && get_class($query) === Builder::class) {
                $query = $modifiedQuery;
            }
        }

        if (is_subclass_of($query, AbstractPaginator::class)) {
            if ($asCollection) {
                return $query;
            }
            return $query->toArray();
        }
        return $asCollection ? $query->get() : $query->get()->toArray();
    }

    abstract public static function create($data, $params = []);

    abstract public static function update($data, $id, $params = []);

    abstract public static function delete($id, $params = []);

    abstract static function getQuery(): Builder;

    /**
     * @param $errors array|string = [
     *       [
     *           'code' => string|int,
     *           'message' => string,
     *           'data' => Optional. Error data. Default empty string.
     *       ],
     *       string
     *  ]
     * @param int|null $status HTTP status the framework's wpErrorToResponse should use
     *        (Route::dispatch converts any returned WP_Error via rest_convert_error_to_response,
     *        which reads error_data['status'] and falls back to 500 when absent).
     * @return WP_Error
     */
    public static function makeErrorResponse($errors, ?int $status = null): WP_Error
    {
        $wpError = new WP_Error();

        if (is_array($errors)) {
            foreach ($errors as $key => $error) {
                if (is_array($error)) {
                    $data = Arr::get($error, 'data', '');
                    if ($status) {
                        $data = is_array($data) ? array_merge($data, ['status' => $status]) : ['status' => $status];
                    }
                    $wpError->add(
                        Arr::get($error, 'code', $key),
                        Arr::get($error, 'message'),
                        $data
                    );
                } else {
                    $wpError->add($key, $error, $status ? ['status' => $status] : '');
                }
            }
        } else {
            $wpError->add($errors, $errors, $status ? ['status' => $status] : '');
        }
        return $wpError;
    }

    /**
     * @param string $message
     * @param mixed $data
     * @return array
     */
    public static function makeSuccessResponse($data, string $message): array
    {
        return [
            'message' => $message,
            'data' => $data
        ];
    }

}
```